前文我们写了第一个 c 语言程序，了解了基本的数据类型。本篇将继续学习：常量、运算符、控制语句和循环语句。

(相关资料图)

#define是用来定义常量和宏的预处理指令。定义常量的一般形式：#define 常量名 常量值。就像这样：

#define MAX_NUM 100 // 定义整型常量 MAX_NUM 并初始化为 100#define PI 3.1415926 // 定义双精度浮点型常量 PI 并初始化为 3.1415926

使用 #define宏定义所定义的常量是不可修改的（const 定义的能被修改），编译器在编译时会将所有代码中用宏定义表示的常量进行替换的操作，即文本替换。这意味着，程序在运行时并没有存储这些常量的值，而是直接使用它们的值来进行计算。例如，以下代码中：

#define MAX_NUM 100int arr[MAX_NUM]; // 这里的 MAX_NUM 在编译时会被替换成 100

在编译期间，编译器会将代码中的 MAX_NUM 替换成 100，因此程序实际上是使用整数值 100 来声明数组 arr 的大小。

const 关键字所定义的常量是可以被修改的。虽然 const 常量不能作为左值（即不能出现在赋值语句的左边），但是通过指针可以修改其所指向的变量的值。请看示例：

#includeint main() {   // 使用 const 关键字定义一个常量   const int val =5;   // 使用指针访问该常量   int *ptr= (int*)&val;   *ptr=10;// 修改存储单元的值   printf("val = %d\n",val);// 输出：val = 5   printf("*ptr = %d\n", *ptr);// 输出：*ptr = 10   return 0;}

虽然我们通过指针访问了 val 的存储单元并将其中的值修改为了 10，但是 val 的值仍然是 5，这是因为 val 被定义为一个 const 常量，所以编译器会对其进行优化。具体来说，编译器可能会在程序中使用 val 的地方直接替换成常量 5，而不是实际读取 val 所在的存储单元的值。这样做可以提高程序的效率。

Tip：我们应该遵守 const 常量的规定，不要尝试通过任何方法来修改 const 常量。

在定义常量时，使用#define和const关键字都可以实现相同的功能，但是建议优先使用 const 关键字来定义常量。原因如下：

1.类型安全：const 常量有具体的类型信息，而使用 #define 宏定义常量是不具备类型信息的。在使用 #define 定义常量时，如果某个常量错误地被用于另一种数据类型的处理过程中，编译器无法发现这样的错误。而使用 const 常量定义常量可以有效避免这种类型错误。1.可读性和可维护性：通过使用 const 来定义常量，可以使代码更加清晰和易于阅读，降低出错率，并且增强了程序的可维护性。相比之下，使用 #define 宏定义的常量只是简单的文本替换，执行代码后看不到定义的常量值，容易对程序的可读性造成影响，难以维护和扩展。1.编译器优化：对于 const 常量，编译器会将其存放在内存的只读区域，从而避免了意外修改它们的值。而使用 #define 宏定义的常量只是简单的文本替换，这意味着编译器无法进行优化。1.作用域：const 常量定义的作用域只局限于定义的文件和其他使用该声明的文件，不影响其他文件中的变量。而 #define 宏定义常量的作用域是全局的，容易导致重名等问题。

因此，总体来说，使用 const 关键字定义常量可以使代码更加清晰、安全、易于维护，并且可以得到编译器的优化作用，建议优先使用 const 来定义常量。

123// 常量值为 123，默认是 int 类型-456// 常量值为 -456，也是 int 类型1776L// 常量值为 1776，长整型

05 // 常量值为 5，八进制表示077// 常量值为 63，八进制表示031UL// 常量值为 25，无符号长整型

0x1A// 常量值为 26，十六进制表示0XF00L// 常量值为 3840，长整型0x3aUL// 常量值为 58，无符号长整型

const float PI =3.1415926;const double E =2.7182818284590452354;

"A" // 常量值为 65，ASCII 码值"\n"// 常量值为 10，换行符"\x41"// 常量值为 65，十六进制值 A 的 ASCII 码值

"This is a string"  // 常量值为字符串的地址"Hello, world!\n"  // 常量值为字符串的地址"Good\bmorning,\bKate"// 常量值为字符串的地址，其中 \b 表示退格符

"Hello" 字符串包含 5 个可见字符，但在 C 语言中，字符串末尾需要添加一个表示字符串结尾的 Null 字符 (\0)，所以实际上这个字符串占用了 6 个字节的内存空间。

在内存中，该字符串被表示为一个字符数组，如下所示：

+---+---+---+---+---+---+|H|e|l|l|o|\0|+---+---+---+---+---+---+

其中，每个字符都占用一个字节（8 位），最后一个空字符 \0表示字符串的结束，告诉程序不再继续处理该字符串。如果没有 Null 字符，程序就无法区分字符串何时停止，那么在处理字符串时可能会出现一些问题，特别是字符串拼接和复制时。

注:在字符串拼接或复制时，目标字符串必须具有足够的内存空间，包括末尾的空字符 \0，否则可能导致缓冲区溢出或不可预期的结果。

定义一个字符串常量。请看示例：

#includeint main() { char*str="hello"; printf("您输入的字符是：%s\n",str); return 0;}

将字符串常量 "hello" 赋值给了指针变量 str，并使用 %s 格式符将其输出。输出结果为：您输入的字符是：hello：

最重要的就是\n（换行符）、\t（水平制表符）。

在计算机编程中，转义字符（Escape Character）是以反斜杠（\）开头的一个或多个字符的序列。这些字符被称作转义序列，可以将一些特殊的字符插入到字符串或字符常量中。

下面是一些常见的转义序列及其含义：

在编程中，使用转义字符可以方便地处理特殊字符，充分利用了计算机的二进制表示方法，并且让代码更加灵活。

水平制表符是一种控制字符，通常用来在文本输出中对齐内容或间隔数据字段。

当程序遇到 \t转义字符时，会在输出中插入一个水平制表符，并将光标移动到下一个制表符位置。这通常相当于将光标向右移动到下一个 8、16 或 32 个字符的位置，具体取决于系统设置和屏幕宽度。

例如下面的代码会输出带有水平制表的两列数字：

printf("1\t2\t3\n");printf("10\t20\t30\n");

输出如下：

1   2   310  20  30

第二行完美对齐了每个数字。这是因为第二行代码使用了水平制表符制作了对齐效果。

下面通过 scanf()输入一个数字和一个字符。请看示例：

#includeint main() { int num; char ch; printf("请输入一个整数和一个字符（用空格隔开）："); scanf("%d %c", &num, &ch); printf("您输入的整数是：%d\n",num); printf("您输入的字符是：%c\n",ch); return 0;}

运行：

请输入一个整数和一个字符（用空格隔开）：123a您输入的整数是：123您输入的字符是：a

这里，我们使用了scanf函数来读取用户输入，读取的格式为 %d %c，其中 %d表示读取一个整数，%c表示读取一个字符。通过&num和&ch的地址传递，将从终端读取到的整数值和字符值分别存储到定义好的变量 num 和 ch 中。

printf()函数是C语言中用于输出格式化字符串的标准库函数。下面是常用的一些输出格式：

在输出格式中还可以使用其他控制字符来控制打印格式（例如空格、正负号等），也可以用 %% 来打印百分号字符。

下面是一个示例程序：

#includeint main() {    int n = 10;    float f= 3.14159;    char c ="A";    char*str = "hello, world!";    printf("整数：%d\n",n);    printf("八进制：%o\n",n);    printf("十六进制：%x\n",n);    printf("浮点数（小数形式）：%f\n",f);    printf("浮点数（指数形式）：%e\n",f);    printf("字符：%c\n",c);    printf("字符串：%s\n",str);    return 0;}

输出结果：

整数：10八进制：12十六进制：a浮点数（小数形式）：3.141590浮点数（指数形式）：3.141590e+00字符：A字符串：hello,world!

C语言中常用算数运算符：

注：整数相除，只保留整数部分。例如 10/3 不会是 3.333

请看示例：

#includeint main() { int a = 10, b = 3; float c = 4.5, d = 2.0; printf("%d + %d = %d\n",a,b,a+b); printf("%d - %d = %d\n",a,b,a-b); printf("%d * %d = %d\n",a,b,a*b); printf("%d / %d = %d\n",a,b,a/b);// 整数相除，只保留整数部分 printf("%d %% %d = %d\n",a,b,a%b);// 取余运算符 % printf("%.2f * %.2f = %.2f\n",c,d,c*d); printf("%.2f / %.2f = %.2f\n",c,d,c/d);// 浮点数相除，保留小数部分 return 0;}

输出：

10+3=1310-3=710*3=3010/3=310%3=14.50*2.00=9.004.50/2.00=2.25

注：10 / 3 = 3。在C语言中，整数相除只保留整数部分是因为在计算机内部处理数据时使用的是二进制数（0和1），而二进制数是不能用来表示小数的。前面我们知道 float 表示数的方式和 int 不同。如果需要得到 3.3333，可使用浮点数进行除法运算。就像这样：

inta=10,b=3;floatresult= (float)a/ (float)b;

题目：输入数字并按照逆序输出

实现：

#includeint main() { int num,temp,reversed_num=0; printf("请输入一个数字："); scanf("%d", &num); temp=num; while(temp!=0) {// 循环计算逆序数   reversed_num=reversed_num*10+temp%10;   temp/=10;  } printf("您输入的数字的逆序为：%d\n",reversed_num); return 0;}

测试：

请输入一个数字：6789您输入的数字的逆序为：9876

关系运算符是用于比较两个值之间的大小或者关系的运算符，例如大于（>）、小于（<）、等于（==）、大于等于（>=）、小于等于（<=）和不等于（!=）

常见的有逻辑与 &&、逻辑或 ||、逻辑非 !

逻辑与和逻辑或都支持短路求值 ：当左操作数已经能够决定整个表达式的结果时，右操作数将不会被计算。例如，在 if (a && b) 中，如果变量 a 的值为 false，则无论变量 b 的值是什么，整个表达式的结果一定是 false。

当逻辑非 ! 运算符作用于一个非零值时，其结果为 false；当它作用于零值时，其结果为 true。

按位与(&)：将两个操作数对应的位进行逻辑与操作，即两个位都为1时，结果才为1，否则为0。例如，6 & 3 = 2，二进制为 0110 & 0011 = 0010。

按位或(|)：将两个操作数对应的位进行逻辑或操作，即两个位中有一个为1时，结果就为1，否则为0。例如，6 | 3 = 7，二进制为 0110 | 0011 = 0111。

按位异或(^)：将两个操作数对应的位进行逻辑异或操作，即两个位不相同时，结果为1，否则为0。例如，6 ^ 3 = 5，二进制为 0110 ^ 0011 = 0101。

按位取反(~)：将操作数的每个位取反，即0变成1，1变成0。例如，~6 = -7，二进制为 ~0110 = 1001。

左位移(<<)：将操作数的各二进制位全部左移若干位，高位丢弃，低位补0。例如，6 << 2 = 24，二进制为 0110 前移2位补0，变为 011000 = 24。左移动两位相当于乘以4。

右位移(>>)：将操作数的各二进制位全部右移若干位，低位丢弃，高位补0（对于正数）或补1（对于负数）。例如，6 >> 2 = 1，二进制为 0110 后移2位补0，变为 0001 = 1。

题目：一组数据，例如 1 1 2 2 4 3 3，除了4出现1次，其他都出现两次，请用异或快速找到只出现一次的数字，这里是4。

分析：可以利用异或运算的性质来解决该问题。异或运算的规则是，相同的两个数异或结果为0，不同的两个数异或结果为1。

程序实现：

#include   int main()  {      int arr[] = {1, 1, 2, 2, 4, 3, 3};      int n = sizeof(arr) / sizeof(arr[0]);      int result = 0;      for (int i = 0; i < n; i++) {          result ^= arr[i]; //异或操作      }      printf("只出现一次的数字是：%d\n", result);      return 0;  }  

题目：统计字符 a 在 ASCII 码表中对应的数字 97 的二进制表示中有多少个 1

程序实现：

#include int main(){  int c = 97; // 字符 a 对应的ASCII码值为 97  int count = 0;  for(int i = 0; i < 8; i++) {    if(c & 1) {      count++;    }    c >>= 1;  }  printf("字符 a 在ASCII码表中对应的数字 97 的二进制表示中有 %d 个 1\n", count);  return 0;}

结果分析：

第一次循环：i = 0，c & 1 的结果为 1，count 的值加 1，然后 c 右移一位，变成 00110000。第二次循环：i = 1，c & 1 的结果为 0，不处理，然后 c 右移一位，变成 00011000。第三次循环：i = 2，c & 1 的结果为 0，不处理，然后 c 右移一位，变成 00001100。第四次循环：i = 3，c & 1 的结果为 0，不处理，然后 c 右移一位，变成 00000110。第五次循环：i = 4，c & 1 的结果为 0，不处理，然后 c 右移一位，变成 00000011。第六次循环：i = 5，c & 1 的结果为 0，不处理，然后 c 右移一位，变成 00000001。第七次循环：i = 6，c & 1 的结果为 1，count 的值加 1，然后 c 右移一位，变成 00000000。第八次循环：i = 7，c & 1 的结果为 1，count 的值加 1，然后 c 右移一位，变成 00000000。

=

a +=10 等于 a = a + 10

例如：result = a > b ? a : b

Tip：单目运算符：例如 a++。双目运算符: 例如 a + b

请看示例：

#include int main(){ int a = 1;  a += a++; // 笔者认为这句话等于：a = a + a; a++;  printf("%d", a); // 所以是 3  a = 1;  a += ++a; // 笔者认为这句话等于：++a; a = a + a;  printf("%d", a); // 所以是4  return 0;}

有的编译器对该代码报错如下：

/workspace/CProject-test/main.c:7:11: warning: unsequenced modification and access to "a" [-Wunsequenced]  a += a++; // a = a + a; a++;  ~~ ^  /workspace/CProject-test/main.c:11:10: warning: unsequenced modification and access to "a" [-Wunsequenced]  a += ++a; // ++a; a = a + a;  ~~ ^  2 warnings generated.  

其中 warning: unsequenced modification and access to "a" [-Wunsequenced]这个警告出现的原因是因为在同一表达式中有多个操作，而且这些操作对同一个变量进行修改和访问，并且它们之间没有明确定义的顺序。这种情况下，代码的行为是未定义的。

在看这段代码，请问 k 是多少：

int i = 3, k;  k = (++i) + (++i) + (i++);  

该代码在腾讯云和阿里云中结果不相同。建议避免这种类型的表达式。

请看示例，这段代码会输出什么：

#include#includeint main() { inti;  // 逗号运算符 for(i=1; i<=3,printf("a"); i++) {   printf("%d\n", i);   sleep(1);  } return 0;}

该程序会一直运行下去。每秒输出一行：

a1  a2  a3  a4  a5  ...  

这是因为表达式i <= 3, printf("a")实际上等价于(i <= 3), printf("a")，其结果总是为 true。

题目：用 if、else if、else 实现2个数字的计算，数字和操作符都通过 scanf 函数输入。

程序实现（关注 if、else if、else 的用法即可）：

#includeint main() { double num1, num2; char operator; printf("计算2个数的加减乘除。例如 33 * 2：\n"); scanf("%lf%c%*c%lf",&num1,&operator,&num2); if(operator=="+") {   printf("%.2lf+%.2lf=%.2lf\n", num1, num2, num1+num2);  }elseif(operator=="-") {   printf("%.2lf-%.2lf=%.2lf\n", num1, num2, num1-num2);  }elseif(operator=="*") {   printf("%.2lf*%.2lf=%.2lf\n", num1, num2, num1*num2);  }elseif(operator=="/") {   if(num2==0) {     printf("错误：除数不能为0。\n");    }else{     printf("%.2lf/%.2lf=%.2lf\n", num1, num2, num1/num2);    }  }else{   printf("错误：无效的操作符。\n");  } return 0;}

测试：

开始运行...  计算2个数的加减乘除。例如 33 * 2：  33 * 2  33.00 * 2.00 = 66.00  运行结束。  

switch语句用来判断一个表达式的值与若干个常量值中的哪一个相等，并执行相应的代码（可以和if互换）。其一般的语法格式如下：

switch (表达式){        case 常量1:        // 常量1匹配时执行的代码        break;        case 常量2:        // 常量2匹配时执行的代码        break;        ...        default:        // 表达式的值与所有常量都不匹配时执行的代码        break;}

其中，表达式为需要被判断的值，而常量1、常量2等则为待匹配的常量值，需要用case关键字进行标识。如果表达式的值与某个常量相等，则执行相应的代码，并使用break语句跳出整个switch结构；如果表达式的值与所有常量都不匹配，则执行default后面的代码块，并同样使用break语句跳出整个switch结构。

需要注意的是，每个case语句都必须以一个常量值开头，且后面必须紧跟一个冒号（:）。另外，case语句中的代码块可以为空，但不能省略冒号。如果一个case语句的代码块为空，且没有接着的break语句，则程序会继续执行下一个case语句的代码块。

用 switch 重写上述 if 的示例：

#includeint main(){ doublenum1, num2; charoperator; printf("计算2个数的加减乘除。例如 33 * 2：\n"); scanf("%lf%c%*c%lf",&num1,&operator,&num2); switch(operator)  {   case"+":     printf("%.2lf+%.2lf=%.2lf\n", num1, num2, num1+num2);     break;   case"-":     printf("%.2lf-%.2lf=%.2lf\n", num1, num2, num1-num2);     break;   case"*":     printf("%.2lf*%.2lf=%.2lf\n", num1, num2, num1*num2);     break;   case"/":     if(num2==0) {       printf("错误：除数不能为0。\n");      }else{       printf("%.2lf/%.2lf=%.2lf\n", num1, num2, num1/num2);      }     break;   default:     printf("错误：无效的操作符。\n");     break;  } return 0;}

测试：这里故意输入一个无效操作符，进入 default。就像这样：

开始运行...  计算2个数的加减乘除。例如 33 * 2：  1 # 2  错误：无效的操作符。  运行结束。  

注：假如不小心将default输错，例如 defualt，再次测试 1 # 2，就不会在提示错误：无效的操作符。这是因为 defualt:变成了 goto 标签。在大型项目中较难发现此问题。

在 C 语言中，goto 是一种流程控制语句，它可以直接跳转到程序中的某个标识符（通常是标签 label），从而实现有选择的跳转或循环。语法格式如下：

// 定义标签label: statement;// 跳转到标签goto label;

goto 语句使用时需要小心谨慎，因为它会破坏代码结构的正常逻辑，使得程序难以理解和调试，建议只在特定情况下使用。

使用 goto 语句来实现在用户输入错误时重新输入的功能。请看示例：

#includeint main(void){ int num;start: printf("请输入一个正整数："); scanf("%d",&num); if(num<=0)  {   printf("输入错误，请重新输入！\n");   goto start; // 跳转到 start 标签处重新开始输入  } printf("您输入的正整数为：%d\n", num); return 0;}

测试：

开始运行...  请输入一个正整数：-1  输入错误，请重新输入！  请输入一个正整数：-2  输入错误，请重新输入！  请输入一个正整数：-3  输入错误，请重新输入！  请输入一个正整数：4  您输入的正整数为：4  运行结束。  

题目：假设房价为 100 万元，每年涨幅为 5%，工资为 20 万元，现在需要多少年才能买得起这套房子？

实现：

#includeint main(void){ double house_price = 100.0; // 房价，单位：万元 const double interest_rate = 0.05; // 每年增长率为 5% double annual_salary = 20.0; // 年薪，单位：万元 double savings= 0.0; // 积蓄，单位：万元 int year = 0; while(savings < house_price)  {    house_price *= (1 + interest_rate); // 更新房价    savings += annual_salary; // 更新积蓄    year++;   printf("第%d年，房价为%.2lf万元，积蓄为%.2lf万元\n", year, house_price, savings);  } printf("需要%d年后才能买得起这套房子\n", year); return 0;}

输出：

开始运行...  第 1 年，房价为 105.00 万元，积蓄为 20.00 万元  第 2 年，房价为 110.25 万元，积蓄为 40.00 万元  第 3 年，房价为 115.76 万元，积蓄为 60.00 万元  第 4 年，房价为 121.55 万元，积蓄为 80.00 万元  第 5 年，房价为 127.63 万元，积蓄为 100.00 万元  第 6 年，房价为 134.01 万元，积蓄为 120.00 万元  第 7 年，房价为 140.71 万元，积蓄为 140.00 万元  第 8 年，房价为 147.75 万元，积蓄为 160.00 万元  需要 8 年后才能买得起这套房子  运行结束。  

题目：用for 重写 while 的示例

实现：

#includeint main(void){ doublehouse_price=100.0; // 房价，单位：万元 constdoubleinterest_rate=0.05; // 每年增长率为 5% doubleannual_salary=20.0; // 年薪，单位：万元 doublesavings=0.0; // 积蓄，单位：万元 intyear; //年份 for(year=1; savings

输出与 while 相同：

开始运行...  第 1 年，房价为 105.00 万元，积蓄为 20.00 万元  第 2 年，房价为 110.25 万元，积蓄为 40.00 万元  第 3 年，房价为 115.76 万元，积蓄为 60.00 万元  第 4 年，房价为 121.55 万元，积蓄为 80.00 万元  第 5 年，房价为 127.63 万元，积蓄为 100.00 万元  第 6 年，房价为 134.01 万元，积蓄为 120.00 万元  第 7 年，房价为 140.71 万元，积蓄为 140.00 万元  第 8 年，房价为 147.75 万元，积蓄为 160.00 万元  需要 8 年后才能买得起这套房子  运行结束。  

inti; for(i=1; i<=10; i++)  {   if(i%2==0)// 只输出奇数     continue;   printf("%d", i);// 输出奇数  }

intj; for(j=1; j<=10; j++)  {   if(j>5)// 只输出前5个数     break;   printf("%d", j);// 输出前5个数  }

#includeint main(void){ inti; intcount=0; for(i=100; i<=200; i++)  {   if(i%3==0){     printf("%d", i);      count++;     if(count==5){       printf("\n");        count=0;      }    }  } return 0;}

#includeint main(void){ inti; int num; doublesum=0; doubleaverage; printf("请输入五个整数：\n"); for(i=0; i<5; i++)  {   scanf("%d",&num);    sum+=num;  }  average=sum/5.0; printf("这五个数的平均值为：%.1lf\n", average); return 0;}

开始运行...  请输入五个整数：  1 2 3 4 5  这五个数的平均值为：3.0  运行结束。  

开始运行...  请输入五个整数：  3  4  5  6  7  这五个数的平均值为：5.0  运行结束。  

#includeint main(void) { intcount=0; printf("由 1、2、3、4 组成的所有互不相同且无重复数字的三位数有：\n"); for(inti=1; i<=4; i++) {   for(intj=1; j<=4; j++) {     for(intk=1; k<=4; k++) {       if(i!=j&&j!=k&&i!=k) {         int num=i*100+j*10+k;         printf("%d", num);          count++;        }      }    }  } printf("\n共计%d个三位数。\n", count); return 0;}

开始运行...  由 1、2、3、4 组成的所有互不相同且无重复数字的三位数有：  123 124 132 134 142 143 213 214 231 234 241 243 312 314 321 324 341 342 412 413 421 423 431 432  共计 24 个三位数。  运行结束。