[C++知识库]【C语言】笔记 day01

C语言笔记

P02_第一个程序

编译型：c语言 ——》汇编 ——》机器语言 ——》CPU执行

解释型：java ——》字节码 ——》解释器 ——》CPU执行

#include <stdio.h>
int main() {
	printf("hello world!");
}

linux环境下

• 编辑：vi test.c

• 编译：gcc test.c -o test

• 执行：./test

windows环境下

• Dev C++

• CodeBlocks

P03_打印

具体指的是输出

• 可见字符、转义字符
• \n换行。
• 每行写不完行尾用\，下一行为上一行的延续。
• 函数、关键字中间也可以用，注意下行开头如果有空格、缩进也会被解释，会导致识别不了。
• printf格式化输出函数，print打印，f即format格式化

printf("要打印的内容");
printf("要打印的内容\n");
// 下面也是一种写法
// f 第一个字母要没有缩进，否则会失败
print\
f("这样也是可以的");

常见的转义字符

举例说明

• C语言君你给我听好了，你要忽略它的存在，并且把下一行当作是上一行的延续！

#include <stdio.h>

int main() {
	printf("hello\n");
	// 正确
	printf("007\
	008\n");

	// 正确
	print\
f("009");

	// 错误
	// printf("0
	// 1");
	
	// 错误
	// print\
  // f("009");
}

P04_变量

确定目标并提供存放的空间

命名规则：

• 变量名只能是英文字母(A-Z,a-z)和数字(0-9)或者下划线(_)组成

• 第一个字母必须是字母或者下划线开头(不能是数字)

• 变量名区分大小写

• 不能使用关键字

关键字

• 32个基本关健字

• 1999年c99标准增加5个

• 2011年c11标准增加7个

数据类型

• char 字符型，占用1字节

• int 整型，通常反映了所用机器中整数的自然长度

• float 单精度浮点型

• double 双精度浮点型

声明变量语法

• 数据类型 变量名
• 如 int a

举例说明

#include <stdio.h>

int main() {
	int a;
	char b;
	float c;
	double d;

	a = 520;
	b = 'F';
	c = 3.14;
	d = 3.141592653;

	printf("鱼C工作室创办于2010年的%d\n", a);
	printf("I love %cishC.com!\n", b);
	printf("圆周率是：%.2f\n", c); // 精确到小数点后2位
	printf("精确到小数点后9位的圆周率是：%11.9f\n", d); // 总共11位小数点后9位

	return 0;
}

P05_常量和宏定义

变量

常量：

• 整型常量：520,1314,123
• 实型常量：3.14,5.12,8.97
• 字符常量
  • 普通字符：‘L’,‘o’,‘v’,‘e’
  • 转义字符：’\n’,’\t’,’\b’
• 字符串常量：“FishC”
• 符号常量：使用之前必须先定义

定义符号常量 宏定义

• #define 标识符 常量
• 比如：#define URL “http://www.fishc.com”、#define NAME “鱼C工作室”

示例

#include<stdio.h>

#define NAME "小甲鱼"

#define YEAR 2010

int main (){
	printf("%s成立于%d年",NAME,YEAR);
}

标识符：和关键字命名规则一样，不能使用关键字来命名标识符。

操作系统读取到字符串是如何具体判断要给其多少空间来存储？

• 在编译的时候，在字符串的最后一个字节位置追加一个\0的字符，用来标识结束位置。
• 判断长度

P06_数据类型

数据类型

• 基本类型

  • 整数型 int、short int、long int、long long int （short int<=int<=long int<=long long int）
  • 浮点型 float、double、long double
  • 字符型 char
  • 布尔型 _Bool
  • 枚举型 enum

• 指针类型

• 构造类型

  • 数组型
  • 结构型
  • 联合性

• 空类型

sizeof运算符

用于获取数据类型或表达式的长度

sizeof（变量或对象），可以不加括号，空格隔开。如sizeof(a)或sizeof a

sizeof(类型),如sizeof(int)

signed和unsigned类型限定符 限定char类型和任何整数类型的取值范围

• signed 带符号位，可以存放负数

• unsigned 不带符号位，只能存放正数和0

[signed] short [int]

unsigned short [int]

[signed] int

unsigned int

[signed] long [int]

unsigned long [int]

[signed] long long [int]

unsigned long long [int]

示例

#include <stdio.h>

int main()
{
	short i; // === signed short i;
	unsigned short j; // 只能存放正数和0

	i = 1;
	j = -1;	
	printf("i = %d", i); // 1
	printf("j = %d", j); // 65535

	return 0;
}

#include <stdio.h>

int main() {
	int i;
	char j;
	float k;

	i = 123;
	j = 'C';
	k = 3.14;

	printf("size of int is %d\n", sizeof(int)); // 4
	printf("size of i is %d\n", sizeof(i)); // 4
	printf("size of char is %d\n", sizeof(char)); // 1
	printf("size of j is %d\n", sizeof j); // 1
	printf("size of float is %d\n", sizeof(float)); //4
	printf("size of k is %d\n", sizeof k); //4

	return 0;
}

#include <stdio.h>

int main() {
	printf("int = %d\n", sizeof(int));	        
	printf("short int = %d\n", sizeof(short));
	printf("long int = %d\n", sizeof(long));
	printf("long long int = %d\n", sizeof(long long));
	printf("char = %d\n", sizeof(char));
	printf("_Bool = %d\n", sizeof(_Bool)); 
	printf("float = %d\n", sizeof(float));
	printf("double = %d\n", sizeof(double));
	printf("long double = %d\n", sizeof(long double));

	return 0;
}
//int = 4
//short int = 2
//long int = 8
//long long int = 8
//char = 1
//_Bool = 1
//float = 4
//double = 8
//long double = 16

P07_取值范围

比特位

• CPU能够读懂的最小单位——比特位，单位bit缩写b

字节

• 内存机构的最小寻址单位——字节，单位Byte缩写B

1Byte=8bit、1个字节等于8比特

1字节最大：二进制11111111 十进制255 十六进制FF

n个连续的1等于2的n次方减一

#include<stdio.h>
#include<math.h>

int main(){
  int result = pow(2,32)-1;
  printf("result=%d\n",result);
  return 0;
}

符号位

存放signed类型的存储单元中，左边第一位表示符号位。

如果该位为0表示该整数是一个正数；

如果该位为1,表示该整数是一个负数。

补码

一个32位的整数变量，除去左边第一个符号位，剩下的表示值得只有31个比特位

事实上计算机是用补码的形式来存放整数的值。

正数的补码是该数的二进制形式

负数的补码：

（1）先取得该数的绝对值的二进制形式 -7 绝对值7的二进制10000111

（2）将第一步的值按位取反 11111000

（3）最后将第二步的值加1 11111001

补码的最大值127最小值-128

01111111 127

…

00000001 1

00000000 0

11111111 -1

11111110 -2

10000000 -128

基本数据类型的取值范围

P08_字符和字符串

字符类型事实上是一个特殊的整数类型

字符类型事实上是一个特殊的整型，因此它也有取值范围，signed char 的取值范围是 -128 ~ 127；unsigned char 的取值范围是 0 ~ 255。

字符类型与普通整数类型的不同之处

C 标准规定普通整数类型默认使用 signed 修饰符，但没有规定 char 的默认修饰符。因此，使用 signed 或 unsigned 修饰符，是由编译系统自行决定。

存放在字符类型中的变量，都可以被解释为 ASCII 字符表中的对应字符

ASCII 字符表 -> 传送门

标准 ASCII 字符表使用7位二进制数来表示所有的大写和小写字母，数字 0 到 9、标点符号， 以及在美式英语中使用的特殊控制字符。

其中，ASCII 字符表上的数字 0 ~ 31 以及 127（共 33 个）分配给了控制字符，用于控制像打印机等一些外围设备。这些是看不到的。数字 32 ~ 126 分配给了能在键盘上找到的字符，这些是所见即所得的。

字符串

C 语言没有专门为存储字符串设计一个单独的类型，因为没必要。我们之前已经说过，字符串事实上就是一串字符。所以只需要在内存中找一块空间，然后存放一串字符类型的变量即可。

声明字符串的语法：

char 变量名[数量];

对其进行赋值，事实上就是对这一块空间里边的每一个字符变量进行赋值。我们通过索引号来获得每个字符变量的空间。

变量名[索引号] = 字符;

比如：

char name[6];

name[0] = 'F';
name[1] = 'i';
name[2] = 's';
name[3] = 'h';
name[4] = 'C',
name[5] = '\0';

当然，我们可以把声明和定义写在一块，语法是这样的：

char name[6] = {'F', 'i', 's', 'h', 'C', '\0'};

其实，中括号（[]）里边的数量咱可以不写，编译器会自动帮你计算的。

char a[] = {'F', 'i', 's', 'h', 'C', '\0'};

事实上可以直接在大括号写上字符串常量，字符串常量用双引号括起来，还记得吧：

char a[] = {"FishC"};

使用字符串常量有个好处，那就是你不必亲自在末尾添加 ‘\0’，它会自动帮你加上。

最后，如果使用字符串常量的话，这个大括号也是可以省掉的：

char a[] = "FishC";

P09_算术运算符

1. 算术运算符

C 语言通过提供大量的运算符来支持我们对数据进行处理，前边我们将一个值存放到变量中，使用的是赋值运算符，就是等于号（=），上节课对字符串中的某个字符进行索引，使用方括号（[]）作为下标运算符实现。

这一节我们谈的是 C 语言中最常用的运算符——算数运算符。

这里有几点要跟大家说一下：

• 因为键盘上没有乘号和除号两个按键，所以用星号（*）和斜杠（/）代替，这几乎是潜规则了。
• 对于整数间的除法是采取直接舍弃小数部分的方式，而不是什么四舍五入噢。
• 对于浮点数间的除法则能获得一个相对逼近结果的值（如果除不尽或位数特别多的话）。
• 百分号（%）在这里是表示求余数的意思，但求余运算符要求两边的操作数都要是整数，其结果也是整数。

2. 何谓“目”？

大家可能看到有些运算符后边写双目，有些写单目，那么什么是目呢？

我们把被运算符作用的运算对象称之为操作数，比如 1 + 2，那么 1 和 2 就是被加法运算符（+）作用的两个操作数。我们说一个运算符是双目运算符还是单目运算符，就是看它有多少个操作数。

3. 表达式

用运算符和括号将操作数连接起来的式子，我们称之为表达式。

• 1 + 1
• ‘a’ + ‘b’
• a + b
• a + ‘b’ + pow(a, b) * 3 / 4 + 5

4. 运算符的优先级和结合性

请参考：https://fishc.com.cn/thread-67664-1-1.html

5. 类型转换

当一个运算符的几个操作数类型不同时，编译器需要将它们转换为共同的某种数据类型，才能进行运算。

通常情况下，编译器会将占用坑位比较小的操作数，先转换为与坑位较大的操作数的相同类型，然后再进行运算。这样做的目的就是为了确保计算的精确度。

除了编译器帮你自动转换不同类型的操作数之外，C 语言还允许你强制转换操作数的数据类型。做法就是在操作数的前边用小括号将目标数据类型括起来。

P10_关系运算符和逻辑运算符

1. 关系运算符

在 C 语言中，使用关系运算符来比较两个数的大小关系。

关系运算符都是双目运算符，其结合性均为左到右。另外，关系运算符的优先级低于算术运算符，高于赋值运算符。

2. 关系表达式

用关系运算符将两边的变量、数据或表达式连接起来，称之为关系表达式：

• 1 < 2
• a > b
• a <= 1 + b
• ‘a’ + ‘b’ <= ‘c’
• (a = 3) > (b = 5)

关系表达式得到的值是一个逻辑值，即判断结果为“真”或“假”，如果结果为“真”，关系表达式的值为 1，如果为“假”，关系表达式的值则为 0。

3. 逻辑运算符

C 语言总共提供了三种逻辑运算符：

4. 逻辑表达式

用逻辑运算符将两边的变量、数据或表达式连接起来，称之为逻辑表达式：

• 3 > 1 && 1 < 2
• 3 + 1 || 2 == 0
• !(a + b)
• !0 + 1 < 1 || !(3 + 4)
• ‘a’ - ‘b’ && ‘c’

注：关系表达式和逻辑表达式得到的值都是一个逻辑值，也就是表示真的 1 和表示假的 0。但是用于判断一个值是否为真时，以 0 表示假，以任何非 0 的数表示真。一个是编译系统告诉我们的结果，一个是我们让编译系统去判断的，两者方向不同。

5. 短路求值

短路求值又称最小化求值，是一种逻辑运算符的求值策略。只有当第一个运算数的值无法确定逻辑运算的结果时，才对第二个运算数进行求值。

C 语言对于逻辑与和逻辑或采用短路求值的方式。

#include <stdio.h>

int main() {
  int a = 3, b = 3;

  (a = 0) && (b = 5);
  printf("a = %d, b = %d\n", a, b);

  (a = 1) || (b = 5);
  printf("a = %d, b = %d\n", a, b);

  return 0;
}

结果

P11_if 语句

1. 分支结构的作用就是将 C 语言的代码引入歧途

那么光有关系表达式和逻辑表达式还不足以实现分支结构，还需要学习一个新的语句——if 语句。

if 语句的实现有好几种形式，我们逐一给大家介绍一下。

第一种：

…… // 其它语句
if (表达式)
{
    …… // 逻辑值为真所执行的语句、程序块
}
…… // 其它语句

第一种是最简单的，if 后边小括号内填写返回逻辑值的表达式，当然你可以直接填入一个逻辑值，当你填入这个值为非 0 的时候，编译系统就会认为这个逻辑值是真；只有当你填入 0 的时候，才被认为是假的。

第二种：

…… // 其它语句
if (表达式)
{
    …… // 表达式的逻辑值为真所执行的语句、程序块
}
else
{
    …… // 表达式的逻辑值为假所执行的语句、程序块
}
…… // 其它语句

第三种：

…… // 其它语句
if (表达式1) 
{
    …… // 表达式 1 的逻辑值为真所执行的语句、程序块
}
else if (表达式2)
{
    …… // 表达式 2 的逻辑值为真所执行的语句、程序块
}
else if (表达式3)
{
    …… // 表达式 3 的逻辑值为真所执行的语句、程序块
}
  .
  .
  .
else if (表达式n)
{
    …… // 表达式 n 的逻辑值为真所执行的语句、程序块
}
else
{
    …… // 上面所有表达式的逻辑值均为假所执行的语句、程序块
}
…… // 其它语句

P12_switch语句和分支嵌套

1. 处理多分支结构，可以考虑使用语法更简便的 switch 语句

…… // 其它语句
switch (表达式)
{
        case 常量表达式 1: 语句或程序块;
        case 常量表达式 2: 语句或程序块;
        ……
        case 常量表达式 n：语句或程序块;
        default: 语句或程序块;
}
…… // 其它语句

• 这里每个 case 后边的常量是匹配 switch 后边表达式的值
• case 后边必须跟一个常量值，而不能是一个范围
• 如果所有的 case 均没有匹配的，那么执行 default 的内容
• default 是可选的，如果没有 default，并且所有的 case 均不匹配，那么 switch 语句不执行任何动作

2. 使用 break 语句跳出

switch 语句中的 case 和 default 事实上都是“标签”，用来标志一个位置而已。当 switch 跳到某个位置之后，就会一直往下执行，所以我们这里还需要配合一个 break 语句，让代码在适当的位置跳出 switch。

事实上 break 语句在循环中能发挥更大的作用(⊙o⊙)哦！

3. 分支结构的嵌套

如果在一个 if 语句中包含另一个 if 语句，我们就称之为 if 语句的嵌套，也叫分支结构的嵌套。

4. 悬挂 else

这个问题虽然已经为人熟知，而且也并非 C 语言所独有。但即使是有多年经验的 C 程序员，也常常在此失误过！

考虑下面的代码片段：

……
if (x == 0)
    if (y == 0)
        error();
else
    z = x + y;
……

这段代码中编程者的本意是应该有两种主要情况，x 等于 0 以及 x 不等于 0。对于 x 等于 0 的情形，除非 y 也等于 0（此时调用 error 函数），否则程序不作任何处理；对于 x 不等于 0 的情形，程序将 x 与 y 之和赋值给 z。

然而，这段代码实际上所做的却与编程者的意图相去甚远。

原因在于 C 语言中有这样的规则，else 始终与同一对括号内最近的未匹配的 if 结合。如果我们按照上面这段程序实际上被执行的逻辑来调整代码缩进，大致是这个样子：

……
if (x == 0)
    if (y == 0)
        error();
    else
        z = x + y;
……

也就是说，如果 x 不等于 0，程序将不会做任何处理。如果要得到原来的例子中由代码缩进体现的编程者本意的结果，应该这样写：

……
if (x == 0)
{
    if (y == 0)
    {
        error();
    }
}
else
{
    z = x + y;
}
……

现在，else 与第一个 if 结合，即使它离第二个 if 更近也是如此，因为此时第二个 if 已经被括号“封装”起来了。

5. 等于号带来的问题

在 C 语言中使用等号（=）作为赋值运算，使用连续两个等号（==）作为比较运算。一般而言，赋值运算相对于比较运算出现得更频繁，因此字符较少的 = 就被赋予了更常用的含义——赋值操作。此外，在 C 语言中赋值符号被作为一种操作符对待，因而重复进行赋值操作（如 a = b = c）可以很容易地书写，并且赋值操作还可以被嵌入到更大的表达式中。

但是，这种使用上的便利性可能导致一个潜在的问题：当程序员本意是在作比较运算时，却可能无意中误写成赋值运算。

比如下例，该语句本意似乎是要检查 x 是否等于 y ：

if (x = y)
    break;

而实际上是将 y 的值赋给了 x ，然后检查该值是否为零。

再来看看下面的例子：

if (c = ' ' || c == '\t' || c == '\n')
    space = space + 1;

该程序的本意是计算空白字符（空格符、制表符和换行符）的数量，但是由于程序员在比较字符 ’ ’ 和变量 c 时，误将比较运算符 == 写成了赋值运算符 = 。因为赋值运算符 = 的优先级要低于逻辑运算符 || ，因此实际上是将以下表达式的值赋给了 c ：

' ' || c == '\t' || c == '\n'

因为空格（’ '）不等于零（空格的 ASCII 码值为32），那么无论变量 c 此前为何值，上述表达式的值都是 1。

P13_while和do while

1. 循环结构

什么是循环结构？我们为什么需要它呢？

在现实生活中，如果重复很多次做同一件事情，往往会让人感觉很懊恼。

在编程中我们大可不必如此——当我们需要重复执行同一段代码很多次的时候，就可以使用循环结构来解决。

2. while 语句

while (表达式)
        循环体

while 语句的语法非常简单，只要表达式的值为真，那么就会不断执行循环体里边的语句或程序块。

执行过程画成流程图如下：

3. do…while 语句

除了通过 while 语句实现循环，C 语言中还有一个叫 do…while 的语句，也是用于实现循环。

do
    循环体
while (表达式);

如果我们把 while 语句比喻为一个谨慎的小伙子的话，那么 do…while 语句就是一个莽撞的汉子。

因为 while 是先判断表达式，如果表达式结果为真，才执行循环体里边的内容；

而 do…while 则相反，不管三七二十一，先执行循环体的内容再判断表达式是否为真。

注意：do…while 语句在 while 后边一定要用分号（;）表示语句结束。

4. getchar 从标准输入流中获取字符

参考：getchar

函数概要：

getchar 函数从标准输入流（stdin）中获取下一个字符。

相当于调用 getc(stdin) 函数。

函数原型：

#include <stdio.h>
...
int getchar()(void);

返回值：

如果函数调用成功，返回获取的字符（用整型表示其 ASCII 码）。

返回值如果是 EOF，表示该函数调用失败：

• 如果标准输入流位于处于结束的位置，该函数返回 EOF，并设置标准输入流的结束标志符。
• 如果出现其他错误，该函数同样返回 EOF，并设置错误标志符代替。

演示：

#include <stdio.h>

int main()
{
  int count = 0;

  printf("请随意一个英文句子：");

  while (getchar() != '\n')
  {
    count = count + 1;
  }

  printf("你总共输入了%d个字符！\n", count);

  return 0;
}

测试结果

P14_for语句和循环嵌套

1. 入口条件循环和出口条件循环

2. 循环的基本结构

通常一个循环都将涉及到三个动作：

• 初始化计数器
• 判断循环条件是否满足
• 更新计数器

3. for 语句

对于 while 语句，这些动作是分散在三个不同的地方。那如果能够把它们都集中到一块，那么对于后期无论是调试也好修改也罢，无疑就便捷了许多。没错，当年 C 语言作者也是跟我们想到一块去了，所以 for 语句就这么应运而生。

for (表达式1; 表达式2; 表达式3)
        循环体

三个表达式用分号隔开，其中：

• 表达式1是循环初始化表达式
• 表达式2是循环条件表达式
• 表达式3是循环调整表达式

这样一来，for 语句将初始化计数器、循环条件判断、更新计数器三个动作组织到了在一起，那么以后如果要修改循环的次数，每次递进的跨度，或者循环结束条件，只需要在 for 语句后边的小括号内统一修改即可。

4. 灵活的 for 语句

for 语句的表达式1，表达式2和表达式3都可以按照需要进行省略（但分号不能省）：

• for ( ; 表达式2; 表达式3)
• for (表达式1; 表达式2; )
• for (表达式1; ; )
• for ( ; ; )
• ……

注意：如果目的不是特别明确，建议不要这么做，因为程序的可读性会因此而降低！

5. 最后提一下 C99 的新标准：C99 允许在 for 语句的表达式1中定义变量。

#include <stdio.h>

int main()
{
  for (int i=0, int j=10; i < j; i++, j--)
  {
    printf("%d\n", i);
  }

  return 0;
}

注意：在编译时需要加上–std=c99，否则可能会出错。

[fishc@localhost s1e14]$ gcc –std=c99 test.c && ./a.out
0
1
2
3
4

增加这个新特性的原因主要是考虑到循环通常需要一个计数器，而这个计数器出了循环就没什么用了。所以在表达式1的位置定义的变量，活动范围仅限于循环中，出了循环，它就无效了。

6. 循环嵌套

循环结构跟分支结构一样，都可以实现嵌套。

对于嵌套的循环结构，执行顺序是从内到外：先执行内层循环，再执行外层循环。

P15_break和continue语句

1. break 语句

那么在循环体中，如果我们想要让程序在中途跳出循环，那么我们同样可以使用 break 语句来实现。

执行 break 语句，直接跳出循环体。

有一点需要注意的是，对于嵌套循环来说，break 语句只负责跳出所在的那一层循环，要跳出外层循环则需要再布置一个 break 语句才行。

2. continue 语句

当满足某个条件的时候，跳过本轮循环的内容，直接开始下一轮循环。这时候我们应该使用 continue 语句。

当执行到 continue 语句的时候，循环体的剩余部分将被忽略，直接进入下一轮循环。

对于嵌套循环来说，continue 语句跟 break 语句是一样的：它们都只能作用于一层循环体。

3. for 语句和 while 语句执行过程的区别

for 语句和 while 语句执行过程是有区别的，它们的区别在于出现 continue 语句时。

在 for 语句中，continue 语句跳过循环的剩余部分，直接回到调整部分。

在 while 语句中，调整部分是循环体的一部分，因此 continue 语句会把它也跳过。

P16_补充 拾遗

1. 赋值运算符

赋值运算符是 C 语言中用得最多的一个运算符，我们每天都在用它。因此它的设计简便与否直接影响到了 C 语言的开发效率。语法很简单，就是将右边的值放到左边的变量里边，因为它的执行方向是自右向左。

int a;
a = 5;

需要注意的是赋值运算符的左边必须是一个 lvalue，变量名就是 lvalue，但常数就不是了，所以你把 5 写在赋值号的左边就会出错：

5 = a;

编译系统会提示类似于“error: lvalue required as left operand of assignment”的错误。

lvalue 不建立理解为“left value of the赋值运算符”，这里我写了篇文章，大家可以参考下 ->什么是 lvalue，什么是 rvalue？

2. 复合的赋值运算符

由于赋值运算符的使用度非常高，所以 C 语言的作者也想出了一些编辑的方案。

比如：

a = a + 1;

这样写太费劲，你完全可以写成：

a += 1;

同理还有：

a -= 2;
a += 3;
a /= 4;
a %= 5;

3. 自增自减运算符

当我们需要对一个变量加一或减一并赋值给自己的时候，我们可以写成 i++、i— 或 ++i、–i 的形式。

它们也被称为增量减量运算符，或 ++、-- 运算符。

它们的区别是：

• i++ 是先使用变量 i 中保存的值，再对自身进行 ++ 运算；
• ++i 是先对自身进行 ++ 运算，再使用变量 i 的值（这时候变量i的值已经加 1 了）。

另外，自增、自减运算符只能作用于变量，而不能作用于常量或表示。

4. 逗号运算符

逗号表达式的语法是：表达式1，表达式2，表达式3，… ，表达式n

• 逗号表达式的运算过程为：从左往右逐个计算表达式；
• 逗号表达式作为一个整体，它的值为最后一个表达式（也即表达式n）的值。

不过，逗号运算符在C语言的所有运算符中，是最没有地位的那个。

因为连赋值运算符的优先级都比逗号运算符要高，所以……

a = 3, 5

相当于

a = 3;
5;

注意：在 C 语言中看到的逗号，不一定就都是逗号运算符，因为在有些地方，逗号仅仅是被用作分隔符而已。

比如：

int a, b, c; 
scanf("%d%d%d", &a, &b, &c); 

这里逗号都是作为分隔符使用，而不是运算符。

5. 条件运算符

有一个操作数的运算符称为单目运算符，有两个两个操作数称为双目运算符，然而 C 语言还有唯一的一个三目运算符，它的作用是提供一种简写的方式来表示 if-else 语句。

语法：exp1 ? exp2 : exp3;

exp1 是条件表达式，如果结果为真，返回 exp2，如果为假，返回 exp3。

所以：

if (a > b)
{
    max = a;
}
else
{
    max = b;
}

可以直接写成：

max = a > b ? a : b;

6. goto 语句

goto 语句可以说是一个历史遗留，因为早的编程语言都留有很多汇编语言的痕迹，比如 goto 语句就是其中之一。

goto 语句的作用就是直接跳转到指定标签的位置。

语法：goto 标签;

其中标签需要被定位于某个语句的前边，比如：

#include <stdio.h>

int main()
{
        int i = 5;

        while (i++)
        {
                if (i > 10)
                {
                        goto Label;
                }
        }

Label:  printf("Here, i = %d\n", i);

        return 0;
}

重要：开发中要尽量避免使用 goto 语句。其实就连 C 语言的作者也觉得 goto 语句非常容易被滥用，并且建议一定要谨慎使用，甚至根本不用它。

但在一种情况下使用 goto 语句是情有可原的，那就是当面临要跳出多层循环的时候，使用 goto 语句要比多个 break 语句好使。

7. 注释

C 语言的注释有两种方式，一种是大家常用的，将注释写在两个连续斜杠的后边：

// 这是注释，编译器不会理会

这样每一行注释的开头都需要有两个斜杠，有时候你可能需要写多行注释，那你可以使用 /* 注释的内容 */ 来实现：

/* 这是一个跨越多行的注释
   这是注释，编译器不会理会
   这是注释，编译器不会理会
   这是注释，编译器不会理会
   这是一个跨越多行的注释 */