C++ Practical-1 day1

系列文章目录

点击直达——文章总目录

文章目录

C++ Practical-1 day1

Overview

  • C++不练习coding，就相当于空中楼阁，基础不扎实
  • 光吃不干，等于没吃

1.hello world

#include 

int main(int argc, char *argv[]) {
    std::cout << "Hello world!" << std::endl;
    std::cin.get();
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

1.1.main函数中 argv argv含义

在C++中，main函数是一个特殊的函数，它是每个C++程序的入口点。main函数可以有两种不同的形式：

  1. int main()
  2. int main(int argc, char *argv[])

其中，argc和argv是可选参数，它们用于处理命令行参数。

  • argc（argument count）是一个整型变量，表示命令行参数的数量。
  • argv（argument vector）是一个字符指针数组，包含了命令行参数的值。

当你在命令行（如终端或命令提示符）中运行一个程序时，你可以传递一些参数给程序。这些参数会通过argc和argv传递给main函数。

例如，如果你有一个C++程序，你可以通过以下方式运行它：

./program arg1 arg2 arg3
  • 1

在这个例子中：

  • argc的值将是4（包括程序本身的名称，所以实际参数数量是3）。
  • argv将包含以下元素：
    • argv[0]是程序的名称（“program”）。
    • argv[1]是第一个参数（“arg1”）。
    • argv[2]是第二个参数（“arg2”）。
    • argv[3]是第三个参数（“arg3”）。

这是main函数使用argc和argv的一个简单示例：

#include 

int main(int argc, char *argv[]) {
    std::cout << "Number of arguments: " << argc << std::endl;
    for (int i = 0; i < argc; ++i) {
        std::cout << "Argument " << i << ": " << argv[i] << std::endl;
    }
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

在这个程序中，main函数打印出参数的数量和每个参数的值。如果你运行这个程序并传递一些参数，它将输出这些参数的数量和值。

2.annotate 注释


// #include 

/* #include  */

#if 0
#include 
#endif

#if 1
#include 
#endif
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

在C++中，有几种不同的注释方法：

  1. 单行注释：
    使用两个斜杠 // 开始，直到行尾的所有内容都会被视为注释。

    // 这是一个单行注释
int a = 5; // 这也是一个单行注释
    • 1
    • 2

  2. 多行注释：
    使用 /* 开始，*/ 结束。这种注释方式可以跨越多行。

    /* 这是一个多行注释
   它可以跨越多行。 */
int a = 5;
    • 1
    • 2
    • 3

  3. 文档注释（也称为文档化注释）：
    使用 /** 开始，*/ 结束。这种注释方式通常用于生成文档。

    /**
 * 这是一个文档注释
 * 它通常用于生成文档。
 */
int a = 5;
    • 1
    • 2
    • 3
    • 4
    • 5

  4. 嵌套注释：
    C++标准不支持在多行注释中嵌套注释。如果你尝试这样做，只有第一个 */ 之前的部分会被当作注释，剩下的部分会被当作代码。

    /* 这是一个注释
/* 这不是注释，而是代码 */
int a = 5; // 这会导致编译错误
    • 1
    • 2
    • 3

  5. 条件编译注释：
    使用 #if, #ifdef, #ifndef, #else, #elif, #endif 指令可以创建条件编译注释，这些指令可以控制代码的编译。

    #define DEBUG
#if defined(DEBUG)
// 调试模式下的代码
std::cout << "Debug mode" << std::endl;
#else
// 非调试模式下的代码
std::cout << "Release mode" << std::endl;
#endif
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

  6. 预处理指令注释：
    使用 # 开头的预处理指令，如 #include, #define, #undef 等，虽然它们不是注释，但它们用于控制编译过程。

    #include  // 包含标准输入输出库
#define PI 3.14159 // 定义常量PI
    • 1
    • 2

在实际编程中，单行注释是最常用的，因为它简洁且易于使用。多行注释则适用于需要注释掉较大块代码的情况。文档注释通常与文档生成工具（如Doxygen）一起使用，以自动提取注释生成程序文档。

3.判断闰年

在C++中，判断一个年份是否为闰年可以通过以下规则：

  1. 如果年份能被4整除且不能被100整除，则为闰年。
  2. 如果年份能被400整除，则也是闰年。

基于这些规则，你可以使用以下C++代码来判断一个年份是否为闰年：

#include 

bool isLeapYear(int year) {
    if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
        return true;
    } else {
        return false;
    }
}

int main() {
    int year;
    std::cout << "Enter a year: ";
    std::cin >> year;

    if (isLeapYear(year)) {
        std::cout << year << " is a leap year." << std::endl;
    } else {
        std::cout << year << " is not a leap year." << std::endl;
    }

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

这段代码定义了一个isLeapYear函数，它接受一个整数参数year，并返回一个布尔值，指示该年份是否为闰年。然后在main函数中，程序会提示用户输入一个年份，然后调用isLeapYear函数来判断并输出结果。

这是一个简单且有效的判断闰年的方法。

4.union

在C++中，union是一种特殊的数据类型，允许在相同的内存位置存储不同的数据类型。union可以包含多个成员，但任何时候只能存储其中一个成员的值。union的大小由最大的成员决定。

下面是一个union的简单示例：

#include 
#include 
// 定义一个名为Data的union
union Data {
    int    i;
    double f;
    char   str[20];
    struct {
        int x;
        int y;
        int z;
    } u;
    int k;
};

int main() {
    Data data;

    // 存储整数值
    data.i = 10;
    std::cout << "data.i: " << data.i << std::endl; // 输出: data.i: 10

    // 存储浮点数值
    data.f = 220.5;
    std::cout << "data.f: " << data.f << std::endl; // 输出: data.f: 220.5

    // 存储字符串
    strcpy(data.str, "C++ Union");
    std::cout << "data.str: " << data.str << std::endl; // 输出: data.str: C++ Union

    data.u.x = 1;
    data.u.y = 2;
    data.u.z = 3;
    data.k   = 4; // 覆盖掉第一个int空间值
    printf("%d %d %d %d\n", data.u.x, data.u.y, data.u.z, data.k);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

在这个例子中，Data是一个union，它包含一个整数i，一个浮点数f和一个字符数组str。在main函数中，我们创建了一个Data类型的变量data，并分别给它的成员赋值。

请注意，尽管data可以存储不同类型的值，但一次只能存储一个成员的值。这意味着，当你给data.f赋值时，data.i的值会被覆盖，同样，当你给data.str赋值时，data.i和data.f的值都会被覆盖。

union的一个常见用途是处理不同的数据类型，但你知道在任何给定时间只会使用其中一种类型。这可以节省内存，因为不需要为每种可能的类型分配单独的空间。

注意：在使用union时，需要确保不会同时访问多个成员，因为这会导致未定义的行为。此外，当使用union存储和访问数据时，需要格外小心，以避免数据覆盖和内存泄漏等问题。

关于作者

WeSiGJ
微信公众号
共同分享，共同交流， 共同学习!
注：本文转载自blog.csdn.net的WeSiGJ的文章"https://blog.csdn.net/wesigj/article/details/142448715"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！