【无标题】

最新推荐文章于 2025-06-29 22:00:04 发布

一捺乀夫

最新推荐文章于 2025-06-29 22:00:04 发布

阅读量1.1k

点赞数

CC 4.0 BY-SA版权

文章标签： c语言

本文链接：https://blog.youkuaiyun.com/qq_63086136/article/details/124230932

文章目录

一 ,数据类型
二,运算符和表达式
三 ,循环结构
四，函数
五，数组
六，结构体和联合体
七，指针
八，宏定义

一 ,数据类型

1 整型数据
整型常量
(1) 八进制整常数：八进制整常数必须以数字0开头，即以0作为八进制数的前缀。数码取值为0～7。八进制数通常是作为无符号数(正整数)来使用的。
(2) 十六进制整常数：十六进制整常数的前缀为0X或0x。其数码取值为0～9、A～F或a～f。十六进制数通常也是作为无符号数(正整数)来使用的。
(3) 十进制整常数：十进制整常数没有前缀。其数码为0～9。

整型变量可以分为基本型、短整型、长整型
(1) 基本型：int。
(2) 短整型：short int或short。
(3) 长整型：long int或long。
(4) 无符号型：unsigned。
（5）有符号型：signed （4，5可与前三者进行组合）

2，浮点型数据
实型也称为浮点型。实型常量也称为实数或浮点数。在Ｃ语言中，实数只采用十进制。它有两种形式：十进制小数形式和指数形式。
(1) 十进制小数形式。
0.0、25.0、5.789、0.13、5.0、300.、 -267.8230等，注意：必须有小数点。
(2) 指数形式
2.1E5(等于2.1×105)

3 字符数据
1，字符常量
字符常量就是用单引号括起来的一个字符。例如，‘a’、‘b’、’=’、’+’、’?'等都为字符常量。

在Ｃ语言中，使用字符常量要注意以下几点：
(1) 字符常量只能用单引号括起来，不能用双引号或其他括号。
(2) 字符常量只能是单个字符，不能是字符串。
(3) 字符可以是字符集中任意字符。

2．字符变量
字符变量是存放字符常量的变量，其取值是字符常量，即单个字符。字符变量的类型说明符是char。
字符变量的定义形式：
char 标识符1，标识符2，… ，标识符n；
例如：char c1, c2, c3, ch ;

定义完成字符变量以后，各个变量可以存放一个字符。下面为上例中定义的字符变量赋值：
c1=‘a’ ; c2=‘b’ ; c3=‘c’ ; ch=‘d’;

二,运算符和表达式

1，
(1) 算术运算符：用于各类数值运算。
(2) 关系运算符：用于比较运算。
(3) 逻辑运算符：用于逻辑运算。
(4) 位操作运算符：参与运算的数据，按二进制位进行运算。
(5) 赋值运算符：用于赋值运算
(6) 条件运算符：用于条件求值(? 😃。
(7) 逗号运算符：用于把若干表达式组合成一个表达式
(8) 指针运算符：用于取内容()和取地址(&)两种运算。
(9) 求字节数运算符：用于计算数据类型所占的字节数。
(10) 特殊运算符
2．运算符可按其运算对象的多少分为以下3类
(1) 单目运算符(仅对一个运算对象进行操作)：！～ ++ - - sizeof等。
(2) 双目运算符(对两个运算对象进行操作)： + - * / % < <= > 等。
(3) 三目运算符(对3个运算对象进行操作) ：？：
此处要注意
(1) 优先级
求解表达式时，总是先按运算符的优先次序由高到低进行操作。
(2) 结合性
当一个运算对象的两侧运算符的优先级相同时，则按运算符的结合性确定表达式的运算顺序。它分为两类：一类运算符结合性为“从左到右”；另一类运算符结合性为“从右到左”。
3 基本算术运算符
算术运算符有以下几种：
(1) 加法运算符“+”：加法运算符为双目运算符具有左结合性。
(2) 减法运算符“-”：减法运算符为双目运算符。具有右结合性。
(3) 乘法运算符“”：双目运算，具有左结合性。
(4) 除法运算符“/”：双目运算，具有左结合性。参与运算量均为整型时，结果也为整型，舍去小数。如果运算量中有一个是实型，则结果为双精度实型。
(5) 求余运算符“%”：双目运算，具有左结合性。要求参与运算的操作数必须为整型。求余运算的结果等于两数相除后的余数。
自增与自减运算符
（6） ++”和“- -”，分别称为自增运算符和自减运算符。它们是从右向左结合的单目算术运算符。
前置形式：++i、- -i，它的功能是在使用i之前，i值先加(减)1(即先执行i+1或i-1，然后再使用i 值)。
后置形式：i++、i- -，它的功能是在使用i之后，i值再加(减)1(即先使用i值，然后再执行i+1或i-1)。即前置运算是“先变后用”，而后置运算是“先用后变”。

注意当一个算术表达式中存在多个算术运算符时，各个运算符的优先级与常规算术运算相同，即先乘、除和取余，再计算加、减，同级运算符的计算顺序是从左向右，即先计算左边的算术表达式，再计算右边的算术表达式
（7）逗号运算符及逗号表达式其一般形式为：
表达式1, 表达式2
其求值过程是分别求两个表达式的值，并以表达式2的值作为整个逗号表达式的值。

三 ,循环结构

1.while 循环语句

一般格式
while(循环继续条件)
{ 循环体语句组；}
在这里插入图片描述

执行过程
先判断“循环继续条件”表达式，
再执行“循环体语句组”

2 do while循环语句
一般格式
do
{ 循环体语句组; }
while(循环继续条件);
在这里插入图片描述

执行过程：
先执行“循环体语句组”，
再判断“循环继续条件”表达式
do -while循环至少要执行一次循环语句

3 for循环语句一般格式
for([变量赋初值]；[循环继续条件]；[循环变量增值])
{ 循环体语句组；}
在这里插入图片描述
执行过程
(1) 求解“变量赋初值”表达式。
(2) 求解“循环继续条件”表达式。
如果其值非0，执行(3)；
否则，
转至(4)。
(3) 执行循环体语句组，并求解
“循环变量增值”表达式，然后转
向(2)。
(4) 执行for语句的下一条语句

4 多重循环
当循环中的内嵌语句是循环语句时，称为循环的嵌套使用。内嵌的循环中嵌套循环，称为多重循环。

5 break语句与continue语句
break语句用来结束循环或结束switch语句执行。
语法：break；
说明：(1) 在循环或switch语句中执行break语句，可使程序转到该块结束处继续运行，从而使得循环结束或switch语句结束。
(2) 若是在循环或switch语句的嵌套中执行break语句，则程序转到外层的循环或switch语句嵌套中。
外循环或switch块{
内循环或switch块{
……
最内循环或switch块{
……
break;
}
……
}
}

continue语句的作用是结束本次循环，进行下一次循环判定。
语法：continue；
说明：
(1)在循环中执行continue语句，程序将转到循环判定条件处继续运行，从而使程序跳过循环体中剩余的语句而强行执行下一次循环。
(2) continue语句用在while、do -while、for等循环体中,常与if条件语句一起使用，用来加速循环
（3）continue语句与break语句不同，它不终止循环的运行，而只是结束本次循环。break语句则是强制终止整个循环过程。
在嵌套循环的情况下，continue语句只对包含它的最内层的循环体语句起作用。break语句也只能终止并跳出最近一层的结构。

四，函数

函数的定义
类型名函数名(形式参数表列)
{ 说明部分
执行部分
}
函数的调用
1．函数调用的一般形式
函数名(实际参数表列)
2．函数的调用过程

(1) 分配内存单元。
(2) 将实参表达式的值依次赋值给对应的形式参数；
若是无参函数，则无参数传递过程。
(3) 执行函数体。分配内存单元，再执行函数体中的语句。执行到return语句时，计算返回值，释放为变量和形参变量分配的内存空间，返回主调函数继续执行。

3．函数调用的方式
按被调函数在主调函数中出现的位置来分，可以有以下3种函数调用方式：
（1)作为函数语句调用。
这种情况下，函数一般不带返回值。
如 “scanf("%d",&b);”。

(2) 作为函数表达式调用。
这种方式要求函数是带返回值的。
如 “z=2 *min(x,y)；”。

(3) 作为函数参数调用。
这时也要求函数有一个确定的返回值。
如“y=min(84,min(44,28));”
函数声明

函数声明的一般形式
一般采用函数原型进行声明：
函数类型函数名(形参类型1, 形参类型2, …)；
或：函数类型函数名(形式参数表列)；

 例如：  char letter (char cl,char c2); 
       或   char letter(char ,char );

#总结函数声明的位置
函数声明语句的位置应该在函数定义之前。

(1) 文件的开头处。例如：
char letter(char cl,char c2); /* 以下两行在所有函数之前 /
float f(float x,float y);
void main()
{…} / 不必对它所调用的函数进行声明 /
char letter(char cl,char c2) / 定义letter函数 /
{…}
float f(float x,float y) / 定义f函数 */
{…}

(2) 主调函数内。即将函数声明放在主调函数内的声明部分，如在main函数内进行声明，则只有在main函数内才能识别该函数。

变量

  存储类型包括作用域与生存期两个方面。

  变量的作用域指变量在源程序代码中的有效区域。在这个区域内程序可以访问该变量，即可以引用该变量的值，也可以对该变量赋值，离开了这个区域该变量或者不存在，或者存在但不能访问。

 变量的作用域取决于变量的定义位置和存储类别。依据变量的定义位置，可以区分局部变量和全局变量。

 局部变量是指只在程序源代码的某个局部可以使用，即只能在函数或语句块中起作用的变量；
 全局变量是指在整个程序的源代码区域都可以使用，即可以在一个文件范围内或一个程序的所有文件范围内起作用的变量。
     在函数内部(或复合语句内部)定义的变量称为局部变量或内部变量。
局部变量只在本函数范围内有效，也就是说局部变量的作用域是变量定义所在的函数内
    在函数外部定义的变量称为全局变量或外部变量，全局变量可以为本文件中其他函数所共用，其作用域是从定义或声明的位置开始，直至它所在源程序文件的结束(如果声明在函数内，则只在函数内有效)。

五，数组

一维数组的定义

数组在使用之前要对数组的名字、类型及其长度(即数组中元素的个数)进行定义。
定义一维数组的格式如下：
<类型标识符> 数组名[数组长度]
例如：int math[5];
该数组共有5个元素，分别为:
math[0], math[1], math[2], math[3], math[4]

(1)整型数组表示数组中的每个元素都是整型变量。
(2) 在定义数组时，还应给出数组的长度，即数组中元素的个数。数组的长度只能用常量表达式表示。例如，如下的定义是错误的：

int i=5;	  float math[i];

i是变量，不可以用变量定义数组的长度。
(3) 数组中的元素从0开始编号，所以在math数组中，元素的个数是5，元素的编号是0～4，即没有math[5]这个元素。
(4) 数组元素的地址表示方式：
在元素前加&。如：
&math[0] 表示元素math[0]的地址
&math[2]表示元素math[2]的地址
math[0]是该数组的第一个元素，&math[0]也是math数组的起始地址，因此就有&math[0]=math

数组初始化格式：
<类型标识符> 数组名[数组长度]={初值列表};
“初值列表”是用逗号隔开的数值。例如：

int math[5]={60,70,80,90,100};

经过上面的定义和初始化之后：
math[0]=60, math[1]=70, math[2]=80, math[3]=90, math[4]=100。

(1) 数组长度可以缺省，当“数组长度”没有给出时，系统将按照“初值列表”中的数值个数自动给数组确定长度。例如：int math[ ]={60,70,80,90,100};
系统会根据初值列表中的5个数为数组math确定其长度为5。
(2) 可以只给部分元素赋值。因数组长度与提供的初值个数不同，数组长度不能省略。例如，想定义math数组长度为10，而只给出5个初值，不能省略数组长度：
int math[10]={60，70，80，90，100};
这样只初始化了math[0]～math[4] 5个元素，而对于math[5]～math[9]，系统将自动为其填充初值0。
在定义数值类型的数组时只要给出一个初值，其后的元素就全部赋0值。

(3) 如果在定义数组时只给出了数组的长度并没有赋初值，那么，数组中各元素的值为随机数。

数组元素的表示形式为：
数组名[下标]
下标可以是整型常量、整型变量或整型表达式。例如：
math[0]，math[i]，math[i+1], math[i]=math[0]+math[1]+5

(1)定义数组时用到的“数组名[数组长度]”和引用数组元素时用到的“数组名[下标]”是完全不同的。例如：

int math[5]; ／*定义数组长度为5*/
score=math[3]; /*引用math数组中下标为3的元素。此时3不代表数组长度*／

(2) 数组长度只能是常量或常量表达式，数组下标既可以是整型常量，也可以是整型变量或整型变量表达式。

二维数组在内存中的存放顺序

“按行优先”，所以student数组在内存中的存放顺序为：第0行、第1行、第2行。
数组名student仍然表示该数组的首地址。
数组中每个元素的地址仍然是在元素前加&，
如用&student[1][1]表示student[1][1]的地址。而且有student=&student[0][0]。
注意：在这个例子中，不存在一维下标为3，二维下标为5的任何元素。

二维数组：数组名[下标][下标];
例如：array[2][3]表示array数组中第2行第三列的一个元素。 array[2][3]=123 是给该元素赋值。
注意1：在引用前必须先定义，如 int array[4][5];
注意2：在引用数组元素时注意不要越界。例如： array[4][5]=123;

字符数组的定义
一维：char 数组名[长度];
例如：char lastName[5];
定义了一个名为lastName，长度为5的字符型数组。
根据C语言先定义、后赋值的规则，给这5个元素赋值如下：
lastName[0] = ‘Z’; lastName[1] =‘h’;lastName[2] = ‘a’;
lastName[3] =‘n’; lastName[4] =‘g’;

二维：char 数组名[一维长度] [二维长度];
对字符数组的初始化采用如下方式：
char lastName[5]={ ‘Z’, ‘h’, ‘a’, ‘n’, ‘g’ };
上述语句把5个字符分别赋给lastName [0]～lastName [4]这5个元素。
定义和初始化一个二维字符数组，例如：
char lastName[3][5]= {{‘Z’, ‘h’, ‘a’, ‘n’, ‘g’},{ ‘L’, 'i ’ },{ ‘W’, ‘a’, 'n ', ‘g’ }};

六，结构体和联合体

结构体类型的定义形式为：
struct 结构体名
{
成员说明表列
};
结构体类型的成员表列说明：
{
类型说明符1 成员标识符1;
类型说明符2 成员标识符2;……
类型说明符n 成员标识符n;
}

struct student
{
	long number;
	char name[20];
	char class[20];
	float Math;
  	float English; 
};

定义的方式

1.先定义结构体类型，再定义结构体变量
struct 结构体名
{
成员说明表列
};

2.在定义结构体类型的同时定义结构体变量
struct 结构体名
{
成员说明表列
}结构体变量列表

对于结构体类型已经定义的结构体变量的初始化

struct student
{
  	long number;
  	char name[20];
  	char class[20];
  	float Math;
  	float English;
};
struct student stu1={1009, "Lilin", "Tongxin1201", 87, 89};

结构体类型定义、结构体变量定义和初始化同时完成

struct student
{
  	long number;
  	char name[20];
  	char class[20];
  	float Math;
  	float English;
}stu1={1009, "Lilin", "Tongxin1201", 87, 89};

1.引用结构体变量中的成员
引用结构体变量成员的一般形式为：
结构体变量名.成员名
其中的圆点为成员运算符，它的运算级别是最高的。
例如：stu1.number、tea1.department[0]等。
如果成员本身又是一个结构体类型的变量，则在访问该结构体变量的成员时，应采取逐级访问的方法。如要得到学生的出生日期，则可以这样引用：
stu1.birthday.month、stu1.birthday.day、stu1.birthday.year
2.将结构体变量作为整体引用
只有在两个结构体变量具有相同的结构体类型时，才可以将一个结构体变量作为一个整体赋值给另一个结构体变量。
例如：

struct teacher tea1={2135, "Wangqi", "computer", 3125.9, 85664179}；
struct teacher dean;
dean=tea1;

这样dean中各成员的值均与tea1成员的值相同。

结构体数组的定义
1.先定义结构体类型，再定义结构体数组
struct 结构体名
{
成员说明表列
};
struct 结构体名数组名[数组大小];
例如，定义一个数组psn，数组有5个元素，均为struct person类型变量，可以写为：

struct person
{
		char name[20];
		char add[30];
		long zip;
};
struct person psn[5];

2.在定义结构体类型的同时定义结构体数组
struct 结构体名
{
成员说明表列
}数组名[数组大小];
例如，上面的例子也可以写为：

struct person
{
  	char name[20];
  	char add[30];
  	long zip;
}psn[5];

3.不出现结构体名，直接定义结构体数组
struct
{
成员说明表列
}数组名[数组大小];
例如，上面的例子也可以写为：

struct
{
  	char name[20];
  	char add[30];
  	long zip;
}psn[5];

结构体数组成员的初始化
结构体数组成员初始化的形式与多维数组的初始化形式类似，例如：
struct person psn[10]={{“Yangxiao”, “101 Renmin Road”,046001}, {“Zhaojun”, “25 Jianshe Road”,036002}, {“Qianyu”, “56 Nanjing Road”,046004}};

这里只对结构体数组元素psn[0]、psn[1]、psn[2]的成员赋予了初值，psn[3]～psn[9]的各成员的值仍是不确定的。

.结构体数组成员的引用
一般的引用形式为：
数组名[下标].成员名
对于上面定义的数组psn，下列的引用均是正确的：
psn[0].name; 表示第一个人的姓名(字符串的首地址)。
psn[0].zip; 表示第一个人的邮政编码。
psn[3]=psn[1]; 将结构体数组元素作为一个整体来使用。

联合体
联合体类型定义的一般形式为：
union 联合体名
{
成员说明表列
};
union是关键字，是定义联合体类型必不可少的标识符；联合体名是用户定义的标识符。{}中的内容为联合体成员的类型说明，与结构体类型的成员说明相同。
例如：

union data
{
  	double v; 
  	int n;
  	char c;
};

说明：
(1) 联合体的成员可以是任何类型，包括联合体类型和结构体类型。
(2) 定义联合体类型后，系统并不分配存储空间。

联合体的定义方式
1．先定义联合体类型，再定义联合体变量
union 联合体名
{
成员说明表列
};
union 联合体名联合体变量列表;

例如：

union data
{
  	double v;
  	int n;
  	char c;
};
union data num1,*p,array[5];

2．在定义联合体类型的同时定义联合体变量
union 联合体名
{
成员说明表列
}联合体变量列表;
例如：

union data
{
  	double v;
  	int n;
  	char c;
} num1,*p,array[5];

3.不出现联合体名，直接定义联合体变量
union
{
成员说明表列
}联合体变量列表;
例如：

union
{
  	double v;
  	int n;
  	char c;
} num1,*p,array[5];

说明：
(1) 联合体变量中起作用的成员是最后一次存放的成员，在存入一个新的成员后原有的成员就失去作用了。在num.v赋值之后，num.n、num.c所在的内存单元被覆盖，因而num.n、num.c的值不能确定。
(2) 相同类型的联合体变量之间可以作为一个整体来赋值，但应注意由于联合体变量共用一段内存的关系，赋值的操作其实仅发生于具有相同类型的联合体变量的成员之间。同时应注意不能对联合体变量名赋值，也不能直接输入/输出联合体变量。如下面的语句是错误的：
fig=1;
scanf("%f",&fig);
printf("%f",fig);
(3) 因为在每一瞬时联合体变量的存储单元中只能存放一个成员的值，所以可以对联合体变量初始化，但初始化列表中只能有一个常量。例如：

union data
{
  	double v;
  	int n;
  	char c;
}a={17.8, 90,'w'};

是错误的。
union data a={17.8};
union data a={.c=‘w’};
是正确的。
(4) 联合体变量的地址和它的各成员的地址都是同一地址。例如，&num.v、&num.n、&num.c都是同一个值

七，指针

一、指针
例： int i=168, char j=A, double k=3.456766;
在这里插入图片描述



#include <stdio.h>
main()
{	int a=32766, b=-32766, c[10]; 
	unsigned m=6553;
	float t=3.4e+37;
	printf("a=%d\n",a);
        printf("变量a的地址：%x\n",&a);
	printf("m=%u\n",m);
        printf("变量m的地址：%x\n",&m);
	printf("t=%e\n",t);
        printf("变量t的地址：%x\n",&t);
        printf("数组c[12]的地址：%x\n",c);
}

指针变量的定义、初始化
指针变量定义的形式为：
数据类型 *指针变量名1[=初始值]，*指针变量名2[=初始值]，……；
例如：

int i;
float m;
char c;
int *pa_1=&i；  //* pa_1是指向int型变量的指针变量）
float *pa_2=&m；//* pa_2是指向float型变量的指针
char *pa_3=&c；//*pa_3是指向char型变量的指针变量

首先可以声明指针变量，然后通过初始化，将指针变量指向变量。

{ int a , b ;
  int * p1 ,* p2 ;
  a=100;b=10;
  pointer_1=&a ;      /*把变量a的地址赋给 p1 */
  pointer_2=&b ;      /*把变量b的地址赋给 p2 */
  printf (“%d, , %d\n” , a , b );
  printf (“%d, , %d\n” , * p1 , * p2 ) ;
}

例如·：任意输入两个整数a和b，然后按先大后小的顺序输出a和b。

 {int * p1 , * p2 , * p , a , b ;
  scanf (“%d , %d”, &a ,&b);
  p1=&a;
  p2=&b;
     if(a＜b )
       {  
p1=&b; p2=&a;   /* 交换指针变量的值，即p1、p2所指的变量交换 */
}
     printf(“a=%d, b=%d\n\n”, a, b);
     printf(“max=%d, min=%d\n”, *p1, *p2);
}

指向变量的指针变量的使用

一、指向变量的指针变量的使用

1 给所指变量赋值
通过指针变量给所指向的变量赋值

#include<stdio.h>
void main()
{ 
    int  *p1, *p2 , a, b;
    p1=&a; p2=&b;
    scanf(“%d,%d”, p1,p2);
    printf(“%d,%d”, a, b);
}

2 改变指针变量的指向来访问不同的变量
使两个指针变量交换指向。

#include<stdio.h>
main()
{
    int *p1 , *p2 ,*p , a, b;
    scanf (“%d , %d” , &a , &b);
    p1=&a ; p2=&b ;                       /* p1指向a , p2指向b*/
    printf (“%d , %d\n” ,*p1 , *p2
    p=p1 ; p1=p2 ; p2=p ;                   /* p1和p2交换指向*/
    printf (“%d ,%d\n” , *p1, *p2);            /*输出指针所指向空间的内容*/
}

3 改变所指变量的值

交换两个指针变量指向的变量的值。

#include<stdio.h>
main()
{
   Int *p1 , *p2 ,a , b , temp;
   scanf (“%d , %d” ,&a , &b );
   p1=&a ; p2=&b ;                 /* p1指向 a , p2指向b*/
   printf（“%d , %d\n” ,*p1 , *p2）;
   temp=*p1 ;
*p1=*p2 ;
*p2=temp ;                      /*通过p1和p2, ，交换其所指向的变量的值*/
printf(“%d,%d\n”,*p1,*p2);
}

二、指向一维数组的指针变量的使用
定义一个指向一维数组的指针变量的方法，与前面介绍的指向普通变量的指针变量相同。例如：
int a[9]；
int *p；
我们可以对该指针变量p赋值：
p=&a[0]; 或 p= a;

三，指向二维数组的指针变量的使用
定义二维数组a如下：
int a[3][4];
我们知道这是一个数组名为a的二维数组，a可以看成是由a[0]，a[1]，a[2]构成的一维数组，而a[i]（i=0，1，2）又是一个一维数组，而每个一维数组又都包含4个元素即a[i][0]、a[i][1]、a[i][2]、a[i][3]（i=0，1，2）

八，宏定义

所谓无参宏就是宏名后不带任何参数。
其定义的格式为：
#define 宏名字符串(或数值)
其中的“#”表示这是一条预处理命令, C语言中凡是以“#”开头的命令都为预处理命令。 “define”为宏定义命令。
2.宏定义在使用中应注意以下几点：
（1）宏名的前后应有空格。
（2）宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名。
（3）宏定义命令其后不要跟分号。
（4）字符串（或数值）中如果出现运算符号，则要注意替换后的结果，通常可以在合适的位置加上括号。

宏定义还有一个特点，就是宏替换名可以带有形式参数。在程序中，可以用实际参数代替这些形式参数。
有参宏定义格式：#define 宏名(形参表) 字符串
有参宏调用格式为：宏名(实参表)
2.使用带参的宏定义时需要注意以下几点：
（1）带参宏定义中，宏名和形参表之间不能有空格出现。例如下面的宏：
#define MIN(a,b) (a<b)?a:b
如果写成如下的形式：
#define MIN (a,b) (a<b)?a:b
则C语言将认为该宏没有参数，宏名MIN代表字符串
“(a,b) (a<b)?a:b”
这显然是错误的。
（2）在宏定义中的形参是标识符，而宏调用中的实参可以是常量、变量和表达式。
（3）在宏定义中，字符串内的形参通常要用括号括起来以避免出错。