我的iOS开发小屋C语言发个

C语言大总结

2015-11-05  本文已影响1550人  雾中探雪

C语言大总结

一、基础:

1、进制、位权、1字节等于8位(位是计算机的最小储存单位,字节是计算机最小存储单元)、十进制转换其他进制:连除倒取余,其他进制转换十进制:按权求和
2、单行注释:// 多行注释: /**/ (内容写在量型号之间)
3、数据类型:整形类型、浮点类型、字符类型。
整型类型:长整形(long 4/8)、整形(int 4)、短整型(short 2)
浮点类型:单精度(float 4)、双精度(double 8)
字符类型:字符类型(char 1)
4、常量:程序运行期间不能被改变的量。
常量 类型:整型常量、浮点型常量、字符型常量
变量:实际上是储存区域,也可以做表达式,是程序运 行期间可以被改变的量。
变量定义:由类型符号、变量名、初始值三部分组成(如: int a = 5;)
变量命名规则:由数字、字母、下划线组成的,但不能 以数字开头,不能与关键字重复,不能重复使用变量名(同一作用域),见名知意。
5、赋值运算符:= 把右边的值赋给左边 优先级别最低
算数运算符:+, -, *, / 整型两边相除取整,除数不能为0,% 两边均为正数 ,++ 自增运算符、- - 自减运算符:(它俩在前,先执行,它俩在后,后执行。
6、复合运算符:+= (a += b; 相当于a = a + b); -=; *=; /=; %=;(语法含义同上)
7、表达式:由常量、变量与运算符组合而成(注:表达式会有返回值)
8、输出函数:printf(); 输入函数 scanf()(注:以回车确定输入结束,只有大回车键才会结束;不要再格式串后面加’\n’字符,否则会抵消人工输入的回车)。
转化符:%c->char; %d->int; %sd->short; %ld->long;%f->float、double。
9、转换格式控制:最少占4位:
printf(“%04d”,12); //不足补0
printf(“%4.2f”,1.2345); //保留小数点后两位
printf(“%-4d”,12); //左对齐
\n回车符; \打印\; %%打印%;

二、运算符

1、BOOL类型:只有YES(1)和NO(0)两个值;
bool类型:由ture(非0数字)和flase(0)两种值;
BOOL和bool区别:1)、在C中只有小布尔没有大布尔; 2)、在C和OC中小布尔中非零为真,零为假;3)、在OC中大布尔中1为真,0为假,其它数字原样输出,不做判断条件
2、关系运算符:用于比较运算,结果值有真假两种,结果值由BOOL类型储存
> < >= <= == !=
3、逻辑运算符:由逻辑运算符组成,结果也是非真即假
&&(逻辑与):一假即假(有一边为假则结果为假)
||(逻辑或) :一真即真(有一边为真则结果为真)
!(逻辑非) :对表达式结果取反
4、条件运算符:条件表达式?表达式1:表达式2
如果条件为真,则执行表达式1。 如果条件为假,则执行表达式2。
5、枚举类型:属于构造类型,是一组由符号的整型常量,一一罗列所有状态,罗列所有结果。 enum枚举名{枚举值表}
目的和作用:提高程序可读性;将人能看懂的标示符与计算机能识别的数字建立对应关系

三、程序的三种结构:

1、顺序结构:按照语句顺序执行

2、分支结构:判断条件在两个语句序列中选择,一旦进行判断必须选择其中一个。

if语句:形式一:if (条件表达式) {语句;}
形式二:if (条件表达式) {语句1;} else{语句2;}
形式三:if (条件表达式1) {语句1;} else if条件表达式2){语句2;} else{语句3;}
switch语句:多分支语句,通过判断整形表达式的值,来判断执行那个语句。常与case配合使用。
break:跳出本层循环,如果外层还有循环的话,则执行外层循环,如果外层没有循环,则执行循环后面的代码。(常与if、switch连用)
continue:跳出本次循环,跳出本次循环,遇到continue后,不管continue后面有无代码,均不执行,提前结束当前循环,开启下一次循环。(常与if连用)
arc4random():返回随机数的函数。 如果要一个随机数在【a, b】范围内的整数。公式为:arc4random() % (b - a +1) + a;

3、循环语句:在满足一个条件的情况下反复执行一个语 句序列。

while语句:while(条件表达式){语句;}条件表达式为真执行循环体,一旦为假立即停止执行。
do…while…语句:do{语句;} while (条件表达式),先执行循环体,再判断循环条件直到不满足,才结束循环。
for语句:for(循环变量初始化;循环条件;循环增量){语句;}循环条件为真才执行循环体。

四、一维数组

一维数组:属于构造结构,是由相同类型的成员组成的一组数据。
数组名:存储不同数据类型的数组有各种对应的名称(名称可以随意起),但 要见名知意。
元素:数组由多个成员组合而成,每个成员被称为“数组的元素”

1、定义一个数组

int array[3] = {1, 2, 3};
int:声明数组类型 array:数组名 [5]:数组长度(注:定义数组时,可以省略元素个数,因为编译器会自动推断出元素个数,但是“[]”坚决不能省略。) { } :给数组赋值,元素之间用逗号分隔开(注:1)定义数组时,可以不给每一个元素赋值,没有赋值的元素系统会默认为0。2)定义数组时,给定了数组长度,首元素为0,其他元素不赋值,则默认为0,这样五个元素均为0。3)大括号中最好赋上初始值,因为没有赋值是系统会根据Xcode编译环境来赋值,有时可能有,有时可能无,这样就会出现定义不明,所以建议赋上值。)

2、数组的内存占用

1)使用sizeof()函数求数组占字节数
printf("array[3]数组所占字节数%ld", sizeof(array));
结果:12 因为每个int类型占4个字节,有3个元素,所以共12个字节 。
2)利用sizeof()函数求数组元素个数
先求出数组所占字节数,再求出其中某个元素所占字节数,再相除就得出数组元素个数。
int array[5] = {4, 6, 7, 2, 8};
int a = (sizeof(array) / sizeof(array[1]));
printf("a = %d\n", a); 结果为:a = 5

3、数组元素的访问方式:数组名+下标

1)int array[6] = {12, 21, 32, 23, 25};
访问array中的32这个元素: 数组名:array,下标:从零开始计数,32在第3个位置上,所以32的下标是2。
int temp = array[2];
printf("temp = %d, array[2] = %d\n", temp, array[2]); 结果:32,32
(注:可以直接访问,打印出来,也可以把值赋给另一个相同类型的变量再打印出来)
2)数组下标越界:数组下标超过了数组长度,访问了不属于数组的内存空间。在C中是没有“数组下标越界保护”机制,所以在写代码时,要避免下标越界。
3)修改数组元素

3.1)修改array中的第二个元素为62
int array[6] = {12, 21, 32, 23, 25};
array[1] = 62;
printf("array[1] = %d\n", array[1]);   结果:array[1] = 62
3.2)  定义一个新的数组,array1,将array的元素,原样赋给arrary1.
int array[5] = {12, 21, 32, 23};
int array1[5] = {0};
for (int i = 0; i < 5; i++) {
 array1[i] = array[i];     //  数组的下标可以是常量,也可以是变量
printf("array1[%d] = %d\n", i, array1[i]); // 数组的输出需要for循环进行遍历
}   
//  array1 = array;  数组中不能整体访问数组元素,也不能整体赋值,而要逐一的遍历数组元素,进行访问、赋值、输出。
//  定义一个具有20个元素的数组,每个元素的取值范围是【30,70】,求数组元素的和
     // 1.定义一个整型数组长度为20
    int array[20] = {0};
    //  2.开启一个for循环,使用循环给数组元素赋值
    for (int i = 0; i < 20; i++) {
        //  2.1 生成【30,70】之间的数
        int temp = arc4random() % (70 - 30 + 1) + 30;
        //2.2 将生成的随机数赋值给对应的元素
        array[i] = temp;
        printf("array[%d] = %d\n", i, array[i]);
    }
    //  3.求数组元素的和
    //   3.1定义一个保存和的变量
    int sum = 0;
    //3.2 使用for循环遍历数组元素,同时将元素累加起来
    for (int i = 0; i < 20; i++) {
        // 3.2.1 获取当前数组元素并将获取到的元素加起来
        sum = sum + array[i];
        
    }
    printf("元素总和为%d\n", sum);
//   定义三个数组,将随机产生的数放入其中两个数组中,将这两个数组的值加起来放入第三个数组中
// 1、 定义三个数组,并初始化。
    int array1[10] = {0};
    int array2[10] = {0};
    int array3[10] = {0};
    // 2、 使用一个for循环,给第一个数组和第二个数组赋值,将两个数组个元素加起来,交给第三个元素。
    for (int i = 0; i < 10; i++) {
     // 2.1、 分别把生成的随机数赋给两个数组
        array1[i] = arc4random() % (40 - 20 + 1) + 20;
        array2[i] = arc4random() % (40 - 20 + 1) + 20;
     // 2.2、两数组进行相加
        array3[i] = array1[i] + array2[i];
    // 3、 打印验证结果是否正确
        printf("array1[%d] = %d, array2[%d] = %d, array3[%d] = %d\n", i, array1[i], i,array2[i], i,array3[i]);
   } 

4、冒泡排序

int array[5] = {12, 45, 23, 42, 56};
    //趟数 = 元素个数 - 1;每趟比较的次数 = 元素个数 - 当前的趟数
    //两层for循环,外层丛植比较趟数、内层控制比较次数
        //趟数
        for (int j = 0; j < 5 - 1; j++) {
            //次数
            for (int k = 0; k < 5 - (j+ 1); k++) {
                if (array[k] > array[k + 1]){  //因为每趟比较都要从下标为0开始,j在每次从外层循环进入内层时,都要被初始化为0。因为每次比较,下标都要加一,j在每次内层循环时,也会加一,所以,在这里是用j做下标是没有问题的。
                    //满足交换条件,开始交换位置。
                    //1.定义一个临时变量
                    int temp = array[k];   6
                    array[k] = array[k + 1];
                    array[k + 1] = temp;
                }
            }
        }
    for (int i = 0; i < 5; i++) {
        printf("%d ", array[i]);
    }

5、字符数组

字符数组:保存字符的数组就是字符数组。有’\0’结束标识的字符数组也称为字符串。
定义一个字符数组:声明类型、数组名、数组长度、赋初值
char char_Array[5] = {'h', 'e', 'l', 'l', ‘o’};
//每个字符占一个字节,数组长度是5,所以数组占5*1个字节的内存。
char char_Array[5] = {'h', 'e', 'l', 'l', 'o', '\0'};和char char_Array[5] =“hello”;
是同一个意思都便是定义字符串hello。
字符串和字符数组的区别:
如果字符数组最后一个字符末尾没有‘\0’,则是一个字符数组
如果字符数组最后一个字符末尾有‘\0’,则是这个字符数组就是字符串。
字符串操作函数
strlen():返回字符串的有效字符个数
strcpy():字符串拷贝函数:把第二个参数的值拷贝给第一个参数
strcat() 字符串拼接:把第二个参数的值,拼接到第一个参数的后面
strcmp() 字符串比较:第一个参数大于第二个参数返回一个正整数,第一个参数小于第二个参数,返回一个负整数,两个参数相等,返回零。

五、函数

1、函数:完成某一功能的代码段。

函数名:给这段代码取一个名字,以后就可以通过这个名字来代替这段代码,遵守变量名的命名法则。
函数参数: 有的函数在完成某一任务时需要的材料,我们把在完成任务所需的材料叫函数的参数。 在被调函数中,参数叫“形参”,在主调函数中,参数叫“实参”。
函数参数传递:将实参的值拷贝一份到形参变量的空间中,在被调用函数中操作的参数是新开辟的内存的数值,和实参没有关系。
参数列表:如果没有参数,可以用void修饰,也可以什么都不写,但是小括号不能省略。
函数的返回值:有的函数在完成任务之后,需要把任务结果返回给主调函数,就可以通过return语句来将值返回。注意:return只能返回一个值,同时不能返回数组。
return:return标志着函数的结束,如果return后边有数值,则将这个数值交给主调函数。当return只负责结束函数执行时,可以省略return。return后⾯的语句不再执行。
函数定义:一般定义在main函数前,函数会遭遇嵌套定义。
返回值类型 函数名 (参数列表) {函数实现……return 返回值;}
函数的调用:必须要先定义出来这个函数,定义之后才能调用
函数调用方式:函数名+参数列表
函数类型:无返无参,无返有参,有返无参,有返有参
返回值类型:如果无返回值,必须要使用void修饰符

2、.h和.m文件

1)如果使用多个文件来管理定义函数时,函数的声明要放在.h文件中,函数定义在.m文件中。
2)由于函数的声明和定义在其他文件中,所以想使用该函数,必须先引入声明部分,也就是.h文件

#import"文件名.h"  把这个放在   主函数和系统头文件之间

3) 如果函数定义在主调函数(main)函数之前,函数的声明可以省略,因为在编译时,编译到主调函数时,已经知道该函数被调函数的意义,所以不会出现异常。如果函数定义在主调函数(main)函数之后,务必要在main函数之前对函数进行声明。
4)声明的意义在于:告诉系统,后面将会出现一个该类型的函数。一个完整的自定义函数,应该包括:函数声明、函数定义、函数调用,共三部分。
5)函数声明的方法:将函数的“返回值类型+函数名+形参列表+;”写在导入头文件语句下面,就是一个函数声明。

3、函数的嵌套调用

1)函数可以嵌套调用:在一个函数中,调用另一个函数完成某项功能,这就是函数的嵌套调用。函数可以嵌套调用,但是函数不可以嵌套定义。
2)函数不可以嵌套定义:在定义一个函数时,又定义另一个函数,就叫函数的嵌套定义,这种行为是不允许的。

4、函数的递归调用

函数递归时一定要有出口,否则会造成程序递归环路(死递归),那么程序一定会崩溃。递归调用:自己调用自己完成某项功能。

5、变量的作用域

//  局部变量:只在当前作用域中起效
//  全局变量:不属于任何一个作用域的变量就是全局变量,全局变量可以在当前文件中任何一个地方被访问到(从创建的位置开始,一直到文件结束)
//  如何确定作用域?使用{}来确定作用域,一对大括号,就确定了一个作用域。

六、结构体

1、什么是结构体?

 1、)结构体是一种构造类型,由其他基本数据类型组合而成一种新类型。与数组的区别是:构成结构体的基本数据类型可以不相同,数组必须是相同类型的数据构成。
 2、)结构体必须先声明,声明结构体由哪些数据类型构成的,相当于基本数据类型的“int/char/double”之类的类型说明。
 3、)声明完成后,就在文件中创造出了这种新的类型,就可以使用这种新的类型定义变量来保存数据了。

2、结构体类型的声明

struct+结构体名+{成员标量}+;  结构体声明在.h文件或主函数与系统头文件之间。
eg:struct student {
    char name[20];
    int age;
    char gender;
};

3、结构体定义

1)struct关键字+结构体名,共同组成了变量的类型修饰符。
struct+结构体名+结构体变量名 = {值1,值2};
eg:struct student stu1 = {"zhangSan", 23, 'm'};
2)结构体成员变量的访问
方式:使用结构体变量名+“.”+”成员变量”的方式访问
eg:访问姓名:stu1.name 访问年龄:stu1.age 访问性别:stu1.gender
3)结构体成员变量的修改
先访问到对应的成员变量,然后再修改值
修改成员年龄:stu1.age = 22;
修改成员性别:stu1.gender = ‘f’;(输出打印时用%c)
修改成员姓名:stu1.name = "shuKui"; (这是错误的形式)
因为字符串在C中使用时,字符数组类型保存的数组不能整体赋值,所以使用普通的修改成员变量方法在这里无效,需要使用字符串拷贝函数,达到修改的目的。
strcpy(stu1.name, “shuKui"); (使用strcpy()函数进行字符串的复制替换)

4、结构体数组

保存结构体变量的数组,就是结构体数组。结构体数组和基本数据类型的数组一样,只能保存相同的数据元素(结构体变量类型必须相同)

1)声明一个father类型的结构体数组
typedef struct father {
    char name[20];
    int age;
}father;
2)定义一个father类型的结构体数组
father father[4] = {
{"zhangsan", 12},
{"laowang", 55},
{"xiaotian", 66},
{"xiaoyan", 22}
};
3)访问成员变量的方式:数组变量名 + 下标 + ‘.’ + 成员变量名
访问姓名:father[0].name
访问年龄:father[2].age

七、指针

1、指针:指针就是内存单元编号的另一种称呼。每个内存单元都有一个编号,这个编号就是内存单元的地址,也被称作指针。

指针变量:用来保存“内存单元”地址的变量,就是指针变量。

2、定义一个指针变量

1)int p = NULL; int a = 12;
// int * : 类型声明符,表示变量p是一个整型指针变量。
// int:告诉系统取值时,应该从当前位置取多少字节数据。int表示连续取4个字节。它与指针变量所占字节无关,指针变量所占字节数只与操作系统有关,64位环境下占8字节,32位环境下占4字节。
// 不能使用指针计算数组元素的个数,因为指针所占的内存的字节数至于操作系统的位数有关
// p:变量名,一般我们将指针类型的变量取名叫p。
// NULL:C语言中,使用NULL代替“空”的意思,将NULL赋给指针,则指针此时保存的是内存起始地址,指针指向内存的起始位置。
printf("%p\n", p); // 打印结果0x0,表示内存的起始位置。
// 使用%p作为占位符,来打印指针变量所保存的地址。
2) &:取地址符号,将后边变量的地址取出来,交给指针保存。
将整型变量a的地址,交给整型指针变量p保存。
p = &a; printf("%p\n", p);
3)
:取值运算符,将指针所指的内存地址中保存的数据取出来。
注意:在不同的位置的含义不同,出现在指针定义的位置,表示证明后边的变量名是一个指针。如果前边没有类型修饰符,则表示指针所指向的地址的数值。
int b = *p; printf("%d\n", b);
4)用指针修改变量 a 的值
*p = 23; printf("%d\n", a);
5)指针重指向:就是指针把它里面保存的地址进行个更换。
p = &c; 指针发生了重指向,有原来的指向a改变为指向b。

3、指针的算术运算

p++; // 指针变量进行加法操作,指针所保存的地址将会加若干个单位的字节,每个单位占用的字节数取决于指针的类型。指针从低地址向高地址移动。
p- -; // 指针变量进行减法操作,指针所保存的地址将会减若干个单位的字节,每个单位占用的字节数取决于指针的类型。指针从高地址向低地址移动。
// 普通的加减运算:如果没有小括号干预优先级,则先取值,再将值进行加减操作
// 自增、自减运算:先处理自增、增减,处理完成后,再进行取值操作。

4、指针与数组

1)数组名就是数组的首元素地址,我们可以定义一个指针变量,来存储数组的首地址,这样指针变量指向的就是这个数组。
// 定义一个指针,将指针指向数组array的首地址
int *p = array; // 数组名本身就是地址,所以不需要取地址符&
// 访问数组元素:数组名+下标\指针+下标
printf("array[1] = %d\n", array[1]);
printf("p[1] = %d\n", p[1]);
// 打印指针指向的地址和数组首元素的地址以及数组名指向的地址
printf("%p\n", p);
printf("%p\n", &array[0]);
printf("%p\n", array);
2)数组名和指针的区别:
2.1)指针指向数组的首地址后,可以向数组名一样访问数组元素(数组名/指针);
2.2) 指针变量的地址可以被修改,但是数组名是一个常量,它所保存的地址不能被修改(数组名不能重指向,但是指针可以重指向)
3)// 使用指针的方式来访问数组元素
int temp = *p; int temp1 = *(p + 1); int temp2 = *(array + 1);
// 此时指针P的指向并没有发生改变,而是产生了一个"新指针(p + 1)"指向了第二个元素。
// 通过修改指针P的指向,来访问数组元素;
int temp3 = * (++p); printf("temp3 = %d\n", temp3);
int temp4 = * (++array); // 因为数组名是常量,所以不能通过修改数组名的地址修改数组元素。(这种表示是错误的)

5、使用指针遍历数组

int array[5] = {23, 12, 34, 23, 45};
int *p = array;

6、指针与字符串

1)// 定义一个字符数组用来保存字符串"hello"
char string[] = “hello"; // hello 是存储在常量区的,string将hello拷贝一份放到栈区进行使用。
// 定义一个char类型指针指向string
char *p = string; //这种情况是指针指向有string开辟的栈区的hello的首地址
// 使用指针下标为0的元素改为’a’

7、指针数组

1)char *str[3] = {"ios", "ipad", “imac”};这是指针数组
// str[0],相等于第一个指针,指向ios首地址。
// str[1],相当于第二个字符指针,指向常量区的ipad字符串的首地址。
// str[2],相当于第三个字符指针,指向常量区的imac字符串的首地址。
char srt[3][5] = {"ios", "ipad", “imac"};这是二位数组(两个表达意思一致)
// char * 类型的数组里存的并不是三个字符串,而是三个字符串的首地址。如果用数组存储三个字符串,需要使用二维数组。
// 指针数组中保存的元素都是指针。
// str本质是一位数组,str数组中存储的时char类型的指针。
2)访问
printf("%s\n", str[1]); // 这就访问了str[3]中的第二个元素(字符串)
3)修改:修改指针数组的元素。在这里,就是修改指向。
str1[2] = "Happy Birthday";
printf("%s\n", str1[2]);
4)使用指针打印:1、字符串的地址2、一个完整的字符串3、字符串中,下标为3的字符
// char *p2 = "i love";
// printf("%p\n", p2);
// printf("%s\n", p2);
// printf("%c\n", *(p2+3));
// 打印ipad中的第二个字符。
char *str2[3] = {"ios", "ipad", “imac"}; printf("%c\n", *(str2[1]+1));

8、指针作为函数的参数

// 对两个整型数值进行交换

//  1、函数exchangeNum定义
void exchangeNum(int *a, int *b){   传入的参数必须是指针(地址),这里坚决不能传入数组名,虽然数组名是地址,但是数组是常量怒能被改变所以不能传。(用指针传参本质是把要交换的变量的地址传过去)
    int temp = *a;
    *a = *b;
    *b = temp;
}
int main(int argc, const char * argv[]) {
    int x = 23, y = 88;
    int *p1 = &x;
    int *p2= &y;
//   调用exchangeNum函数
    exchangeNum(p1, p2);
    printf("x= %d, y = %d\n", x, y);
    return 0;
}

9、结构体指针

指向结构体变量的指针就是结构体指针。结构体指针的类型必须和结构体变量的类型一致。

//  声明一个Student类型的结构体变量
typedef struct student {
    char name[20];
    int age;
    float score;
    char gender;
}Stu; 
//  定义一个Student类型的结构体变量,并赋值
Stu stu1 = {"xiaoZeMaLiYa", 22, 98.15, ‘f'};
//    使用结构体变量名+.+成员变量名的方式访问
    printf("%s\n", stu1.name);
    printf("%c\n", stu1.gender);
//  定义一个指针,来指向这个结构体变量
    Stu *p = &stu1;    //   结构体变量名只是一个名称所以需要取地址符
//  使用指针访问结构体变量的成员变量
//  方法一:先取出结构体变量的值,再通过“.”找到它的成员变量
    printf("%s\n", (*p).name);  //  由于.运算的优先级高于*,所以需要用小括号干预他们的运算顺序。
    printf("%d\n", (*p).age);
//  方法二:使用指针名+ -> 访问结构体的成员变量。
    printf ("%s\n", p->name);
    printf("%d\n", p->age);
//  访问name成员变量的首个字符及第六个字符
    printf("%c\n", *(p->name));
    printf("%c\n", *(p->name+5));

10、指针与结构体

结构体数组的数组名就是一个结构体指针,只不过数组名是一个常量,不能修改数组名保存的地址。

typedef struct teacher{
    int num;
    char name[20];
    char gender;
    float score;
}Teacher;
    Teacher *stuu = student;
   //   使用数组名+下标的方式,访问第一个元素的name成员变量
   printf ("%s\n", student[0].name);
   //    使用指针取值的方式来访问第二个元素的num成员变量(不常用)
   printf("%d\n", (*(stuu+1)).num);
   //   使用指针和 -> 的方式访问第三和元素的gender成员变量
   printf("%c\n", (stuu+3)->gender);

八、宏

###1、普通宏
#define kMac 33  //  宏定义:在程序,只要遇到kMac,在编译之前会自动替换为后面的数。  宏不是变量
命名规则: 纯大写或 k + 驼峰法
2、带参宏
#define SUM(A,B) ((A) * (B))   //  带参宏只是将参数原样替换所以一般情况下,要在表示参数的字符上,添加小括号,防止出现运算符优先级别的问题。   
//  带参宏和函数区别:  带参宏会增加预编译的时间,但是不会加大CPU的运算速度;函数虽然在预编译阶段非常快但是占用的CPU内存会加大,增大硬件损耗。
3、条件编译指令
作用:按条件不同,编译不同的代码
  1)第一种形式:如果宏定义了标示符,则编译第一段代码,否则编译第二段代码
#ifdef 标识符
   代码段1
#else
   代码段2
#endif
 2)第二种形式:如果没有定义表示符,则编译代码段1,否则编译代码段2
#ifndef 标识符
   代码段1
#else
   代码段2
#endif
3)第三种形式:如果 常量表达式结果非0  编译器编译代码1,否则编译代码段2
#if 常量表达式
   代码段1 
#else
   代码段2
#endif

上一篇下一篇

猜你喜欢

热点阅读