C语言复习1

复习会结合chatgpt,b站up主Micro_Frank的视频，菜鸟教程.遇到有疑问的代码，我会问问chatgdp,再不行问bing chat 或者copliot。

B站视频链接： 【C语言教程（全网最具有比喻形象的）：此为旧版，我主页已录制新版】https://www.bilibili.com/video/BV1qE411d7Zx?p=38&vd_source=5355451375e90ea63453597279646a58

以后忘了C语言也会看看日记。 ? ?唉，记不得，憋不住。 反正就是写着玩。哈哈！ ?

1.C语言程序基本结构

#include <stdio.h>

int main(void) {
    int age;
    printf("Please input your age: \n");
    scanf_s("%d", &age);

    if (age >= 18) {
        printf("成年!允许玩！ \n");
    }
    return 0;
}

printf: 这是C语言中用于输出格式化信息的函数。
"Please input your age: \n": 这是要输出的格式化字符串。在这里，它是一条提示信息，告诉用户需要输入年龄，并且\n表示换行，使得用户输入的内容会显示在提示信息的下一行。
因此，运行这段代码时，程序会向用户输出 "Please input your age:"，然后等待用户输入年龄。这是一个简单的用户交互示例，用于获取用户的年龄信息。

printf("a: %d\n", a);

a: 是一个字符串常量， 它是字符 'a' 后面紧跟一个冒号和一个空格组成的字符串。
%d 是格式说明符，它告诉 printf 函数，在这个位置要插入一个整数值。
a 是一个整数变量，它的值将替换 %d 的位置。
\n 是一个换行符，它使得输出的内容会换到下一行。
所以，a 在这里既是变量，也是整数值的提供者。整个语句的效果是将字符串 "a: " 和变量 a 的值以指定的格式输出到屏幕上。这种方式在输出中提供了一些上下文信息，使得输出更加易读和有意义。
字符串常量 "a: " 是一个完整的字符串，它包含了字符 'a'、冒号 : 和空格，这是为了提供输出的上下文信息。设计者可能认为在这里添加额外的 'a' 不是必要的，因为 'a' 已经在变量名 a 中表示了。

分号 ;
在 C 程序中，分号是语句结束符。也就是说，每个语句必须以分号结束。它表明一个逻辑实体的结束。分号不写，调试必报错，Java也是这样，没有分号就不是一个完整的语句，有些人刚学代码就容易忘加分号，尤其是后面要写成百上千行代码。

引号""
例如，下面是两个不同的输出语句：
// 冒号在字符串内
printf("Please input your age: \n");

// 冒号在字符串外
printf("Please input your age:");
printf("\n");

为啥一定要引号，忘记引号，生成解决方案会报错，
对于格式字符串，引号是必需的，因为格式字符串是一个字符串常量，而字符串常量在 C 语言中需要由双引号括起来。

printf("Hello, %s! Your age is %d.\n", "guyindong", 20);

"Hello, %s! Your age is %d.\n" 是格式化字符串。其中，%s 和 %d 是格式说明符，表示在字符串中要插入字符串和整数的位置。而"guyindong" 是一个普通的字符串常量，它不是格式化字符串，它只是一个作为 printf 函数参数的常规字符串。

格式化字符串包含格式说明符，用于指定在运行时插入数据的位置和类型，而普通字符串常量只是字符序列。

在 C 语言中，字符串是由字符组成的字符数组，而字符串常量是这样的字符数组的一种表示方式。字符串常量是一种特殊的常量，表示一系列字符的序列，围绕在双引号中。

这是因为在C语言中，引号是用于定义字符串常量的语法规则。双引号告诉编译器这是一个字符串，而不是一个变量名或其他什么.

例如

char name[] = "guyindong";

"guyindong" 是一个字符串常量，它是一个字符数组的初始化值，而这个数组用于存储名字 "guyindong" 的字符序列。由于这是字符串常量，所以它必须用双引号括起来。双引号是C语言中用于表示字符串常量的规定方式，是为了在源代码中明确区分字符串常量和其他元素（比如变量名、关键字等）。这种规定有助于编译器正确地解释和处理源代码。

2.C语言输入的格式

scanf_s("%d", &age); 

这行代码：
scanf_s：这是 C 语言中的一个输入函数，其中的 _s 表示安全版本。scanf_s 是 scanf 的安全版本，为了提高程序的安全性，特别是防范缓冲区溢出的风险。
"%d"：这是格式说明符，告诉 scanf_s 如何解释输入。在这里，%d 用于读取整数。%d 告诉 scanf_s 期望输入一个整数，并将输入的字符解释为整数。
&age：&（取地址）运算符用于获取变量 age 的内存地址。scanf_s 需要知道它可以将读取到的值存储在哪里，因此 &age 提供了存储用户输入整数的地址。
综合起来，scanf_s("%d", &age); 表示程序将等待用户输入一个整数，一旦用户输入了整数，它将被存储在变量 age 中，以便在程序中进一步使用。

C语言关键字

关键字        说明
auto        声明自动变量
break        跳出当前循环
case        开关语句分支
char        声明字符型变量或函数返回值类型
const        定义常量，如果一个变量被 const 修饰，那么它的值就不能再被改变
continue    结束当前循环，开始下一轮循环
default        开关语句中的"其它"分支
do            循环语句的循环体
double        声明双精度浮点型变量或函数返回值类型
else        条件语句否定分支（与 if 连用）
enum        声明枚举类型
extern        声明变量或函数是在其它文件或本文件的其他位置定义
float        声明浮点型变量或函数返回值类型
for            一种循环语句
goto        无条件跳转语句
if            条件语句
int            声明整型变量或函数
long        声明长整型变量或函数返回值类型
register    声明寄存器变量
return        子程序返回语句（可以带参数，也可不带参数）
short        声明短整型变量或函数
signed        声明有符号类型变量或函数
sizeof        计算数据类型或变量长度（即所占字节数）
static        声明静态变量
struct        声明结构体类型
switch        用于开关语句
typedef        用以给数据类型取别名
unsigned    声明无符号类型变量或函数
union        声明共用体类型
void        声明函数无返回值或无参数，声明无类型指针
volatile    说明变量在程序执行中可被隐含地改变
while        循环语句的循环条件

C 中的空格
只包含空格的行，被称为空白行，可能带有注释，C 编译器会完全忽略它。
在 C 中，空格用于描述空白符、制表符、换行符和注释。空格分隔语句的各个部分，让编译器能识别语句中的某个元素（比如 int）在哪里结束，下一个元素在哪里开始。因此，在下面的语句中：
int age;
在这里，int 和 age 之间必须至少有一个空格字符（通常是一个空白符），这样编译器才能够区分它们。另一方面，在下面的语句中：

fruit = apples + oranges; // 获取水果的总数
fruit 和 =，或者 = 和 apples 之间的空格字符不是必需的，但是为了增强可读性，您可以根据需要适当增加一些空格。我觉得代码还是都加空格，毕竟人家的代码都有空格。

3.C语言数据类型
在 C 语言中，数据类型指的是用于声明不同类型的变量或函数的一个广泛的系统。变量的类型决定了变量存储占用的空间，以及如何解释存储的位模式。
C 中的类型可分为以下几种：
类型与描述
1.基本数据类型：它们是算术类型，包括整型（int）、字符型（char）、浮点型（float）和双精度浮点型（double）。

2.枚举类型：它们也是算术类型，被用来定义在程序中只能赋予其一定的离散整数值的变量。

3.void 类型：类型说明符 void 表示没有值的数据类型，通常用于函数返回值。

4.派生类型：包括数组类型、指针类型和结构体类型。

4.C语言变量

变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有特定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。
变量的命名规则：
变量名可以包含字母、数字和下划线 _。
变量名必须以字母或下划线开头。
大小写敏感，即大写字母和小写字母被视为不同字符。
举个例子 _1可以是变量名
C 中的变量定义
变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：

type variable_list;
type 表示变量的数据类型，可以是整型、浮点型、字符型、指针等，也可以是用户自定义的对象。

variable_list 可以由一个或多个变量的名称组成，多个变量之间用逗号,分隔，变量由字母、数字和下划线组成，且以字母或下划线开头。

下面列出几个有效的声明：

定义整型变量：

int age;
以上代码中，age 被定义为一个整型变量。

定义浮点型变量：

float salary;
以上代码中，salary 被定义为一个浮点型变量。

定义字符型变量：

char grade;
以上代码中，grade 被定义为一个字符型变量。

定义指针变量：

int *ptr;
以上代码中，ptr 被定义为一个整型指针变量。

定义多个变量：
int i, j, k;

int i, j, k; 声明并定义了变量 i、j 和 k，这指示编译器创建类型为 int 的名为 i、j、k 的变量。

变量初始化
在 C 语言中，变量的初始化是在定义变量的同时为其赋予一个初始值。变量的初始化可以在定义时进行，也可以在后续的代码中进行。

初始化器由一个等号，后跟一个常量表达式组成，如下所示：

type variable_name = value;
其中，type 表示变量的数据类型，variable_name 是变量的名称，value 是变量的初始值。比如整形int，后面跟变量名，再进行赋值。

下面列举几个实例：

int x = 10;         // 整型变量 x 初始化为 10
float pi = 3.14;    // 浮点型变量 pi 初始化为 3.14
char ch = 'A';      // 字符型变量 ch 初始化为字符 'A'
extern int d = 3, f = 5;    // d 和 f 的声明与初始化
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z

后续初始化变量：

在变量定义后的代码中，可以使用赋值运算符 = 为变量赋予一个新的值。

type variable_name; // 变量定义
variable_name = new_value; // 变量初始化

举例:

int x;          // 整型变量x定义
x = 20;         // 变量x初始化为20
float pi;       // 浮点型变量pi定义
pi = 3.14159;   // 变量pi初始化为3.14159
char ch;        // 字符型变量ch定义
ch = 'B';       // 变量ch初始化为字符'B'

C 中的变量声明
变量声明向编译器保证变量以指定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

变量的声明有两种情况：

1、一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。
2、另一种是不需要建立存储空间的，通过使用extern关键字声明变量名而不定义它。 例如：extern int a 其中变量 a 可以在别的文件中定义的。
除非有extern关键字，否则都是变量的定义。

extern int i; //声明，不是定义
int i; //声明，也是定义

举个简单例子吧: 变量在头部就已经被声明，但是定义与初始化在addtwonum()函数内.

#include <stdio.h>
 
// 函数外定义变量 x 和 y
int x;
int y;
int addtwonum()
{
    // 函数内声明变量 x 和 y 为外部变量
    extern int x;
    extern int y;
    // 给外部变量（全局变量）x 和 y 赋值
    x = 1;
    y = 2;
    return x+y;
}
 
int main()
{
    int result;
    // 调用函数 addtwonum
    result = addtwonum();
    
    printf("result 为: %d",result);
    return 0;
}

这种用法通常不太推荐，因为这样的代码结构可能会导致代码的可读性和维护性下降。最好的做法是在变量的声明和定义时就进行初始化，而不是在函数内部进行。

最好的做法是在变量的声明和定义时进行初始化。在C语言中，可以在声明变量的同时进行初始化。 （gpt原话）

#include <stdio.h>

// 在声明时进行初始化
int x = 1;
int y = 2;

int addtwonum()
{
    // 直接使用全局变量 x 和 y
    return x + y;
}

int main()
{
    int result;
    // 调用函数 addtwonum
    result = addtwonum();
    
    printf("result 为: %d", result);
    return 0;
}

在这个例子中，全局变量 x 和 y 在声明的同时被初始化为 1 和 2。这样，不需要在函数内部进行额外的初始化步骤，而是可以直接在函数中使用这两个已经初始化的全局变量。这提高了代码的可读性和维护性，并避免了在函数内部进行额外的初始化步骤。

程序可以分成多个代码文件:

1. addtwonum.c

   #include <stdio.h>
   /*外部变量声明*/
   extern int x ;
   extern int y ;
   int addtwonum()
   {
    return x + y;
   }
   

   这个文件主要包含了一个函数 addtwonum 的定义。该函数通过使用外部变量 x 和 y 的值计算它们的和，并返回结果。注意，这里只是函数的定义，而实际的变量声明在其他文件中。

2. test.c

   #include <stdio.h>
     
   /*定义两个全局变量*/
   int x = 1;
   int y = 2;
   int addtwonum();
   
   int main(void)
   {
    int result;
    result = addtwonum();
    printf("result 为: %d\n", result);
    return 0;
   }
   

   这个文件包含了两个全局变量 x 和 y 的定义，它们在此文件中分别被赋值为 1 和 2。然后，通过调用 addtwonum 函数，获取并打印这两个变量的和。需要注意的是，函数 addtwonum 的声明是通过 extern 关键字进行的，表明它是在其他文件中定义的。

当这两个文件一起编译和链接时，程序会通过 main 函数计算并输出变量 x 和 y 的和。

下面这一段讲main 函数的是复制chatgdp3.5的原话;

在C语言中，每个程序只能有一个 main 函数，它是程序的入口点。但你可以通过使用函数来模块化你的代码，然后在 main 函数中调用这些函数，以达到类似于多个入口点的效果。此外，你可以使用命令行参数来决定在运行时执行哪一部分代码。

以下是一个简单的C语言示例：

#include <stdio.h>
#include <stdlib.h>

void main_function_1() {
    printf("Main function 1\n");
}

void main_function_2() {
    printf("Main function 2\n");
}

int main(int argc, char *argv[]) {
    if (argc > 1) {
        int choice = atoi(argv[1]);
        switch (choice) {
            case 1:
                main_function_1();
                break;
            case 2:
                main_function_2();
                break;
            default:
                printf("Invalid argument\n");
                break;
        }
    } else {
        printf("Usage: %s [1|2]\n", argv[0]);
    }

    return 0;
}

在这个例子中，通过在命令行中提供参数，你可以选择在运行时执行 main_function_1 或 main_function_2。

./my_program 1

./my_program 2

这将决定在 main 函数中调用哪个功能函数。请注意，此示例中的错误处理较为简单，实际项目中可能需要更复杂的错误检查和处理机制。

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C语言中以下类型的运算符：

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
杂项运算符

1.算术运算符
加减乘除

#include <stdio.h>
 
int main()
{
   int a = 21;
   int b = 10;
   int c ;
 
   c = a + b;
   printf("Line 1 - c 的值是 %d\n", c );
   c = a - b;
   printf("Line 2 - c 的值是 %d\n", c );
   c = a * b;
   printf("Line 3 - c 的值是 %d\n", c );
   c = a / b;
   printf("Line 4 - c 的值是 %d\n", c );
   c = a % b;
   printf("Line 5 - c 的值是 %d\n", c );
   c = a++;  // 赋值后再加 1 ，c 为 21，a 为 22
   printf("Line 6 - c 的值是 %d\n", c );
   c = a--;  // 赋值后再减 1 ，c 为 22 ，a 为 21
   printf("Line 7 - c 的值是 %d\n", c );
 
}

i++:

后增量：这意味着当前的i值在表达式中被使用，然后i被递增。
表达式i++的值是当前的i值，然后i增加1。
示例：

int i = 5;
int result = i++; // result是5，i现在是6

++i:

前增量：这意味着i首先被递增，然后更新后的值在表达式中被使用。
表达式++i的值是i的递增后的值。
示例：

int i = 5;
int result = ++i; // result是6，i现在是6

i ++ 一开始前面结果不变，i值增加1。++ i 开始结果和i都增加1.

关系运算符：

逻辑运算符:
运算符 描述 实例

&& 称为逻辑与运算符。 如果两个操作数都非零，则条件为真。 (A && B) 为假。

|| 称为逻辑或运算符。 如果两个操作数中有任意一个非零，则条件为真。 (A || B) 为真。

! 称为逻辑非运算符。 用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 !(A && B) 为真。

位运算符

赋值运算符

杂项运算符