C语言基础知识汇总
2016-10-03 19:58
459 查看
隔了好久好久没有看C了,近日国庆有空,整理下以前的C语言知识点
第一个没啥好讲的,include类似JAVA的import导包操作,以前学习C的之后一直写#include< stdio.h>老师也没说,不知道是个啥!现在才恍然明白原来是standard i/o的意思.默认是有一个返回值的(void也是可以的,但是C++好像就强制要求要返回值),一般return 0;作为程序的正常结束.
在C中变量需要先定义后使用,不能像java一样,在哪里需要就直接 int i=0;在C中是行不通的.
常用数据类型长度在32 位的系统上
short 出来的内存大小是2 个byte;
int 出来的内存大小是4 个byte;
long 出来的内存大小是4 个byte;
float 出来的内存大小是4 个byte;
double 出来的内存大小是8 个byte;
char 出来的内存大小是1 个byte。
(具体长度和平台有关,可以用sizeof 方法测试一下)
输出时不同输出格式都有那些呢?
(1)d(或i)格式符。用来输出十进制整数,有以下几种用法:
①%d,按整型数据的实际长度输出。
②%md,m为指定的输出字段的宽度。如果数据的位数小于m,
则左端补以空格,若大于m,则按实际位数输出。
③%ld(%mld 也可),输出长整型数据。
例如:long a=123456;
printf(“%ld”,a);
(2)o格式符,以八进制数形式输出整数。格式:%o,%mo,%lo,%mlo都可。
(3)x(或X)格式符,以十六进制数形式输出整数。格式:%x,%mx,%lx,%mlx都可。
(4)u格式符,用来输出unsigned型数据,即无符号数,以十进制数形式输出。
格式:%u,%mu,%lu都可。
(5)c格式符,用来输出一个字符。格式:%c,%mc都可。
(6)s格式符,用来输出一个字符串。格式:%s,%ms,%-ms,%m.ns,%-m.ns都可。
(7)f格式符,用来输出实数(包括单、双精度),以小数形式输出。格式:%f,%m.nf,%-m.nf都可。
注意:单精度实数的有效位数一般为7位,双精度为16位。
(8)e(或E)格式符,以指数形式输出实数。格式:%e,%m.ne,%-m.ne都可。
(9)g(或G)格式符,用来输出实数,它根据数值的大小,自动选f格式或e格式(选择输出时占宽度较小的一种)。
指针原理图:
Note:需要注意的是,指针*p在左与在右的区别:
int i = 0;
int *p = &i;
int j = *p; // *p出现在右边,表示p指向的int型变量的值
*p = 2; // *p出现在左边,表示p指向int型变量的内存空间
多级指针在使用的时候并没有和一级指针有太多的区别,其实就是二级指针就是指向一级指针地址的指针,三级指针就是指向二级指针地址的指针,类推
他是一种指针类型的变量.直接使用指针变量arr,默认是指向数组的首地址
下面是一个int型的数组的赋值与取值操作:
因为数组是一个指针类型的变量,默认指向首地址,我们可以通过指针变量指向地址的偏移来取数组指定位置的值,需要注意的是不同数据类型的偏移量,如:
结构体结构:
需要注意的是定义结构体的关键字struct,还有就是结构体应该在开始的时候声明,结构体名的书写C里面一般都是小写,而不是像java一样类名开头要大写,当然这是编写习惯,大写也不会提示错误
需要注意的是*p一开始并没分配内存,就类似java的一个变量,只是声明了并没有做new的操作,所以我们要new一下,调用C的分配内存的方法给p分配一个person数据类型大小的内存,并把p强转为person类型
在上面我们看到两种给结构体变量赋值的方式,这并没有好坏自分,看个人习惯
方式一:
*p表示数据类型person,这类似java里面 类名.数据类型
方式二:
p表示指针,p->则指向这个数据类型age的地址
在C里面函数需要在开始的时候先声明,当然你在生命的时候实现也是可以的,但是并不推荐这样做
NOTE:函数里面的变量x,y是局部变量和mian里面的x,y是全局变量,当局部变量和全局变量重名时候,在局部变量作用域作用的是局部变量而不是全局变量
我们来举个例子:
执行结果:
我们清楚的可以看到,实际交换值得是局部变量x,y,全局变量x,y的值并没有改变.
那我们要交换连个数的值怎么办呢?
我们需要用指针来交换,我们传入全局变量x,y的地址,交换x,y的地址,达到数据交换的结果,其实交换的不是数据,而是x,y的地址
NOTE:在C里面并不支持方法的重载,也就是说,不能有两个方法的名字是一样的
我们在开始的地方声明了一个add方法,并在后面实现了这个函数,我们在main里面第一了一个传参类型为两个int的函数指针fq,然后将fq指向了add函数的地址在后面我们使用fq就和add的效果一样了.因为他们指向的都是同一个内存地址
我们在开始的地方声明一个fun函数,并在后面实现了它,我们创建了一个结构体person,并定义了一个指针*p,为他分配了person大小的内存,并把它强转为person,我们将person中的函数指针add指向了函数fun,在后面我们为这个add函数传入了参数,并把指针p的age的地址指向了函数的返回值.
NOTE:结构体在C里面真是个有趣的东西
联合结构:
对于联合的不同成员赋值, 将会对其它成员重写.
我们会发现联合和结构体的定义非常的类似
联合的定义:
结构体的定义:
那他们有什么区别呢?
1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻,
联合中只存放了一个被选中的成员, 而结构的所有成员都存在。
2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存
在了, 而对于结构的不同成员赋值是互不影响的。
枚举结构:
如果枚举没有初始化, 即省掉”=整型常数”时, 则从第一个标识符开始, 顺 次赋给标识符0, 1, 2, …。但当枚举中的某个成员赋值后, 其后的成员按依次 加1的规则确定其值。
#define
#error
#if
#else
#elif
#endif
#ifdef
#ifndef
#undef
#line
#pragma
#define
#define指令是一个宏定义指令, 定义的一般形式是:
#define 宏替换名字符串(或数值)
由#define指令定义后, 在程序中每次遇到该宏替换名时就用所定义的字符
串(或数值)代替它。
例如: 可用下面语句定义TRUE表示数值1, FALSE表示0。 (C里面没有true和false的概念,只有大于0(true)和小于等于零(false))
#define TRUE 1
#define FALSE 0
一旦在源程序中使用了TRUE和FALSE, 编译时会自动的用1和0代替。
注意:
在宏定义语名后没有”;”
在Turbo C程序中习惯上用大写字符作为宏替换名, 而且常放在程序开头。
宏定义还有一个特点, 就是宏替换名可以带有形式参数, 在程序中用到
时, 实际参数会代替这些形式参数。
利用宏定义,定义一个全局的方法:
我们可以看到在宏定义的方法参数里我们不需要指定数据类型,(这难道就是泛型的原型吗?哈哈)
我的博客网站http://huyuxin.top/欢迎大家访问,评论!
- Hello,C
//类似于java import 引入头文件 int main() { printf("Hello,C\n");//输入语句 // system("pause");//暂停 让cmd窗口不消失 return 0; } " data-snippet-id="ext.5bb8d5606ae4a3f75e42babc2b126c74" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h>//类似于java import 引入头文件 int main() { printf("Hello,C\n");//输入语句 // system("pause");//暂停 让cmd窗口不消失 return 0; }
第一个没啥好讲的,include类似JAVA的import导包操作,以前学习C的之后一直写#include< stdio.h>老师也没说,不知道是个啥!现在才恍然明白原来是standard i/o的意思.默认是有一个返回值的(void也是可以的,但是C++好像就强制要求要返回值),一般return 0;作为程序的正常结束.
- c的基本数据类型和变量的定义
int main(){ //基本数据类型 字符型 char| 整型 short int long | 浮点型 float double |有符号 signed |无符号 unsigned|void 空 char c = 'a'; short a = 10; int i = 10; long q = 10; float x = 10; double y = 10; printf(" i = %d \n",i); } " data-snippet-id="ext.ee2a10fe64308b41bbcc87f7e41ff8fb" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> int main(){ //基本数据类型 字符型 char| 整型 short int long | 浮点型 float double |有符号 signed |无符号 unsigned|void 空 char c = 'a'; short a = 10; int i = 10; long q = 10; float x = 10; double y = 10; printf(" i = %d \n",i); }
在C中变量需要先定义后使用,不能像java一样,在哪里需要就直接 int i=0;在C中是行不通的.
常用数据类型长度在32 位的系统上
short 出来的内存大小是2 个byte;
int 出来的内存大小是4 个byte;
long 出来的内存大小是4 个byte;
float 出来的内存大小是4 个byte;
double 出来的内存大小是8 个byte;
char 出来的内存大小是1 个byte。
(具体长度和平台有关,可以用sizeof 方法测试一下)
输出时不同输出格式都有那些呢?
(1)d(或i)格式符。用来输出十进制整数,有以下几种用法:
①%d,按整型数据的实际长度输出。
②%md,m为指定的输出字段的宽度。如果数据的位数小于m,
则左端补以空格,若大于m,则按实际位数输出。
③%ld(%mld 也可),输出长整型数据。
例如:long a=123456;
printf(“%ld”,a);
(2)o格式符,以八进制数形式输出整数。格式:%o,%mo,%lo,%mlo都可。
(3)x(或X)格式符,以十六进制数形式输出整数。格式:%x,%mx,%lx,%mlx都可。
(4)u格式符,用来输出unsigned型数据,即无符号数,以十进制数形式输出。
格式:%u,%mu,%lu都可。
(5)c格式符,用来输出一个字符。格式:%c,%mc都可。
(6)s格式符,用来输出一个字符串。格式:%s,%ms,%-ms,%m.ns,%-m.ns都可。
(7)f格式符,用来输出实数(包括单、双精度),以小数形式输出。格式:%f,%m.nf,%-m.nf都可。
注意:单精度实数的有效位数一般为7位,双精度为16位。
(8)e(或E)格式符,以指数形式输出实数。格式:%e,%m.ne,%-m.ne都可。
(9)g(或G)格式符,用来输出实数,它根据数值的大小,自动选f格式或e格式(选择输出时占宽度较小的一种)。
- 循环语句for
int main() { //c99标准 int i; for(i = 0; i[code]#include<stdio.h> int main() { int* p;//定义一个int*类型的指针变量 p int i = 10;//定义一个int类型的变量 i i就有一个内存地址值 //指针赋值 &就是取内存地址,将i的地址赋值给p p = &i; printf("i = %d\n",i);//直接获取i的值 *:获取指针变量指向的值 printf("通过指针对象去获取 i = %d \n",*p); printf("指针变量p = %d \n",p); //重点: 特殊: * & //1 怎么定义指针变量 类型* 变量名; //2 怎么赋值 p = &i; //3 怎么拿值 int i = *p; system("pause");//暂停 让cmd窗口不消失 }
指针原理图:
Note:需要注意的是,指针*p在左与在右的区别:
int i = 0;
int *p = &i;
int j = *p; // *p出现在右边,表示p指向的int型变量的值
*p = 2; // *p出现在左边,表示p指向int型变量的内存空间
- 多级指针
//类似于java import 引入头文件 int main() { //typedef int** pi;//声明新的数据类型,代替了int** 数据类型,类似取别名 //定义多级指针 int i = 10; int* p = &i; int** q = &p; int*** r = &q; //通过r获取i的值 printf("i = %d \n",***r); //通过q获取i的值 printf("i = %d \n",**q); //通过p获取i的值 printf("i = %d \n",*p); //规律:看前面的*号 数量 ,取值的时候,有多少个*,取值的时候就用多少个*号 system("pause");//暂停 让cmd窗口不消失 }" data-snippet-id="ext.c5a6bac3333814ce10e96ddad84384c2" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h>//类似于java import 引入头文件 int main() { //typedef int** pi;//声明新的数据类型,代替了int** 数据类型,类似取别名 //定义多级指针 int i = 10; int* p = &i; int** q = &p; int*** r = &q; //通过r获取i的值 printf("i = %d \n",***r); //通过q获取i的值 printf("i = %d \n",**q); //通过p获取i的值 printf("i = %d \n",*p); //规律:看前面的*号 数量 ,取值的时候,有多少个*,取值的时候就用多少个*号 system("pause");//暂停 让cmd窗口不消失 }
多级指针在使用的时候并没有和一级指针有太多的区别,其实就是二级指针就是指向一级指针地址的指针,三级指针就是指向二级指针地址的指针,类推
- 数组
数组简单来说就是存放指定数据类型的一种数据结构.他是一种指针类型的变量.直接使用指针变量arr,默认是指向数组的首地址
下面是一个int型的数组的赋值与取值操作:
//类似于java import 引入头文件 int main() { //定义数组 int arr[10]; int i; //循环赋值 for(i = 0; i=0; i--) { printf("arr[%d] = %d \n",i,arr[i]); } system("pause");//暂停 让cmd窗口不消失 }" data-snippet-id="ext.12e8ab2bd279bd8cc10170c9ee323773" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h>//类似于java import 引入头文件 int main() { //定义数组 int arr[10]; int i; //循环赋值 for(i = 0; i<10; i++) { arr[i] = i; } //循环输出 倒着输出 for(i=9; i>=0; i--) { printf("arr[%d] = %d \n",i,arr[i]); } system("pause");//暂停 让cmd窗口不消失 }
因为数组是一个指针类型的变量,默认指向首地址,我们可以通过指针变量指向地址的偏移来取数组指定位置的值,需要注意的是不同数据类型的偏移量,如:
int arr[] = {1,5,8}; int i; for(i = 0; i<3; i++) { printf("arr[%d] = %d \n",i,*(arr+i));//指针变量偏移再取值 }
- 字符串
很多人看到标题就会疑惑了,字符串?在开玩笑吧!不多说,看代码:# include<stdio.h> int main() { //C里面没有字符串.需要使用char*指针来表示 int*-->数组 char*-->字符串 char* str="这是C里面的字符串,good.\n"; printf("char* str=%s",str); }
- 结构体
学了java回头看C语言的结构体(或者说是结构),就感觉特别亲切,因为他和类特别像,大概结构体的设计就有面向对象编程的思想在里面结构体结构:
struct 结构名 { 类型 变量名; 类型 变量名; ... } 结构变量;
//定义结构体 struct person { int age; }; int main() { struct person p;//定义一个结构变量 //给结构体里面的属性赋值 p.age = 18; printf("p.age = %d \n",p.age); system("pause");//暂停 让cmd窗口不消失 }" data-snippet-id="ext.d6066db64ae382fbe620055ea0d719af" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> //定义结构体 struct person { int age; }; int main() { struct person p;//定义一个结构变量 //给结构体里面的属性赋值 p.age = 18; printf("p.age = %d \n",p.age); system("pause");//暂停 让cmd窗口不消失 }
需要注意的是定义结构体的关键字struct,还有就是结构体应该在开始的时候声明,结构体名的书写C里面一般都是小写,而不是像java一样类名开头要大写,当然这是编写习惯,大写也不会提示错误
- 结构体指针变量
//类似于java import 引入头文件 //定义结构 struct person { int age; } *p; //定义了一个结构体指针变量 int main() { //动态申请内存 p = (struct person*)malloc(sizeof(struct person)); /* //赋值 (*p).age = 21;//James //输出 printf("p.age = %d\n",(*p).age); */ p->age = 2; printf("p->age = %d \n",p->age); system("pause");//暂停 让cmd窗口不消失 }" data-snippet-id="ext.4737c61d1d7144fde6600b5c55841ee5" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h>//类似于java import 引入头文件 //定义结构 struct person { int age; } *p; //定义了一个结构体指针变量 int main() { //动态申请内存 p = (struct person*)malloc(sizeof(struct person)); /* //赋值 (*p).age = 21;//James //输出 printf("p.age = %d\n",(*p).age); */ p->age = 2; printf("p->age = %d \n",p->age); system("pause");//暂停 让cmd窗口不消失 }
需要注意的是*p一开始并没分配内存,就类似java的一个变量,只是声明了并没有做new的操作,所以我们要new一下,调用C的分配内存的方法给p分配一个person数据类型大小的内存,并把p强转为person类型
p = (struct person*)malloc(sizeof(struct person));
在上面我们看到两种给结构体变量赋值的方式,这并没有好坏自分,看个人习惯
方式一:
(*p).age = 21;//James
*p表示数据类型person,这类似java里面 类名.数据类型
方式二:
p->age = 2;//James
p表示指针,p->则指向这个数据类型age的地址
- 函数
//声明一个函数 int add(int x,int y); int main() { int x = 1,y = 1; //使用函数 int z = add(x,y); printf(" x + y = %d\n",z); system("pause");//暂停 让cmd窗口不消失 } //实现函数 add(int x,int y) { return x + y; }" data-snippet-id="ext.803a7d9dff5358b0e7d8a459a77be2f2" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> //声明一个函数 int add(int x,int y); int main() { int x = 1,y = 1; //使用函数 int z = add(x,y); printf(" x + y = %d\n",z); system("pause");//暂停 让cmd窗口不消失 } //实现函数 add(int x,int y) { return x + y; }
在C里面函数需要在开始的时候先声明,当然你在生命的时候实现也是可以的,但是并不推荐这样做
//声明并实现一个函数,不推荐 int add(int x,int y) { return x + y; } int main() { int x = 1,y = 1; //使用函数 int z = add(x,y); printf(" x + y = %d\n",z); system("pause");//暂停 让cmd窗口不消失 }" data-snippet-id="ext.8f8fada690b48a9c13afd0279bc0899c" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> //声明并实现一个函数,不推荐 int add(int x,int y) { return x + y; } int main() { int x = 1,y = 1; //使用函数 int z = add(x,y); printf(" x + y = %d\n",z); system("pause");//暂停 让cmd窗口不消失 }
NOTE:函数里面的变量x,y是局部变量和mian里面的x,y是全局变量,当局部变量和全局变量重名时候,在局部变量作用域作用的是局部变量而不是全局变量
我们来举个例子:
void swap(int x,int y) { int temp = x; x = y; y = temp; printf("交换之中\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); } int main() { int x = 1; int y = 2; printf("交换之前\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); swap(x,y); printf("交换之后\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); system("pause");//暂停 让cmd窗口不消失 } " data-snippet-id="ext.938d608d1a2c4452fd8c56aca844d1e3" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> void swap(int x,int y) { int temp = x; x = y; y = temp; printf("交换之中\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); } int main() { int x = 1; int y = 2; printf("交换之前\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); swap(x,y); printf("交换之后\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); system("pause");//暂停 让cmd窗口不消失 }
执行结果:
我们清楚的可以看到,实际交换值得是局部变量x,y,全局变量x,y的值并没有改变.
那我们要交换连个数的值怎么办呢?
//void swap(int x,int y) { // int temp = x; // x = y; // y = temp; // printf("交换之中\n"); // printf(" x = %d\n",x); // printf(" y = %d\n",y); //} void swap(int* px,int* py) { int temp = *px; *px = *py; *py = temp; }; int main() { int x = 1; int y = 2; printf("交换之前\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); swap(&x,&y); printf("交换之后\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); system("pause");//暂停 让cmd窗口不消失 } " data-snippet-id="ext.dc28d5cce7118561d1e816cb5af4d85a" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> //void swap(int x,int y) { // int temp = x; // x = y; // y = temp; // printf("交换之中\n"); // printf(" x = %d\n",x); // printf(" y = %d\n",y); //} void swap(int* px,int* py) { int temp = *px; *px = *py; *py = temp; }; int main() { int x = 1; int y = 2; printf("交换之前\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); swap(&x,&y); printf("交换之后\n"); printf(" x = %d\n",x); printf(" y = %d\n",y); system("pause");//暂停 让cmd窗口不消失 }
我们需要用指针来交换,我们传入全局变量x,y的地址,交换x,y的地址,达到数据交换的结果,其实交换的不是数据,而是x,y的地址
NOTE:在C里面并不支持方法的重载,也就是说,不能有两个方法的名字是一样的
- 函数指针
//声明一个函数 int add(int x,int y); int main() { //定义一个函数指针 int (*fp)(int,int); //给函数指针赋值 fp = add; //函数指针的使用 int i = 1,j = 2; int z = fp(i,j); printf("i + j = %d\n",z); system("pause");//暂停 让cmd窗口不消失 } //实现函数 add(int x,int y) { return x + y; }" data-snippet-id="ext.68828294814c04f5833bacac36200def" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> //声明一个函数 int add(int x,int y); int main() { //定义一个函数指针 int (*fp)(int,int); //给函数指针赋值 fp = add; //函数指针的使用 int i = 1,j = 2; int z = fp(i,j); printf("i + j = %d\n",z); system("pause");//暂停 让cmd窗口不消失 } //实现函数 add(int x,int y) { return x + y; }
我们在开始的地方声明了一个add方法,并在后面实现了这个函数,我们在main里面第一了一个传参类型为两个int的函数指针fq,然后将fq指向了add函数的地址在后面我们使用fq就和add的效果一样了.因为他们指向的都是同一个内存地址
- 结构体中的函数指针
//实现函数 int fun(int x,int y); struct person { int age; //函数指针 int (*add)(int,int); }; int main() { //定义一个结构体指针 struct person* p = (struct person*)malloc(sizeof(struct person)); //给函数指针赋值 p->add = fun; int x = 3,y = 1; //通过一个函数 一个一个属性赋值 p->age = p->add(x,y); printf("p->age = %d \n",p->age); system("pause");//暂停 让cmd窗口不消失 } int fun(int x,int y) { return x + y; } " data-snippet-id="ext.a7373867bc05c3b9b5ab7b92550799bf" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> //实现函数 int fun(int x,int y); struct person { int age; //函数指针 int (*add)(int,int); }; int main() { //定义一个结构体指针 struct person* p = (struct person*)malloc(sizeof(struct person)); //给函数指针赋值 p->add = fun; int x = 3,y = 1; //通过一个函数 一个一个属性赋值 p->age = p->add(x,y); printf("p->age = %d \n",p->age); system("pause");//暂停 让cmd窗口不消失 } int fun(int x,int y) { return x + y; }
我们在开始的地方声明一个fun函数,并在后面实现了它,我们创建了一个结构体person,并定义了一个指针*p,为他分配了person大小的内存,并把它强转为person,我们将person中的函数指针add指向了函数fun,在后面我们为这个add函数传入了参数,并把指针p的age的地址指向了函数的返回值.
NOTE:结构体在C里面真是个有趣的东西
- 联合
联合(union )也是一种数据类型, 它是一种特殊形式的变量。联合表示几个变量公用一个内存位置, 在不同的时间保存不同的数据类型 和不同长度的变量,当一个联合被说明时, 编译程序自动地产生一个变量, 其长度为联合中最大 的变量长度。 联合访问其成员的方法与结构相同。同样联合变量也可以定义成数组或指针联合结构:
union 联合名{ 数据类型 成员名; 数据类型 成员名; ... } 联合变量名;
//定义一个联合 union abc { int a;//int 类型 char c;//字符类型 }; int main() { //定义一个联合变量 union abc un; un.a = 98; printf("int a = %d\n",un.a); printf("char c = %c\n",un.c); printf("_______________________\n"); un.c = 'x'; printf("int a = %d\n",un.a); printf("char c = %c\n",un.c); system("pause");//暂停 让cmd窗口不消失 } " data-snippet-id="ext.44e2ffb3bf58dc2ad8cd9c0ec16f3cef" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> //定义一个联合 union abc { int a;//int 类型 char c;//字符类型 }; int main() { //定义一个联合变量 union abc un; un.a = 98; printf("int a = %d\n",un.a); printf("char c = %c\n",un.c); printf("_______________________\n"); un.c = 'x'; printf("int a = %d\n",un.a); printf("char c = %c\n",un.c); system("pause");//暂停 让cmd窗口不消失 }
对于联合的不同成员赋值, 将会对其它成员重写.
我们会发现联合和结构体的定义非常的类似
联合的定义:
union abc { int a;//int 类型 char c;//字符类型 };
结构体的定义:
struct abc { int a;//int 类型 char c;//字符类型 };
那他们有什么区别呢?
1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻,
联合中只存放了一个被选中的成员, 而结构的所有成员都存在。
2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存
在了, 而对于结构的不同成员赋值是互不影响的。
- 枚举
枚举是一个被命名的整型常数的集合.枚举结构:
enum 枚举名{ 标识符[=整型常数], 标识符[=整型常数], ... 标识符[=整型常数], } 枚举变量;
如果枚举没有初始化, 即省掉”=整型常数”时, 则从第一个标识符开始, 顺 次赋给标识符0, 1, 2, …。但当枚举中的某个成员赋值后, 其后的成员按依次 加1的规则确定其值。
//定义枚举类型 (都是整形常量) enum aweek { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY }; int main() { enum aweek today = SUNDAY; printf("today is = %d\n",today); system("pause");//暂停 让cmd窗口不消失 } " data-snippet-id="ext.eca90d95bfe55217b05c0854ffb6ced4" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> //定义枚举类型 (都是整形常量) enum aweek { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY }; int main() { enum aweek today = SUNDAY; printf("today is = %d\n",today); system("pause");//暂停 让cmd窗口不消失 }
- 类型说明
定义一个名字表示这个类型的新名字,关键字typedef,如果你在阅读别人的代码,发现没有看过的数据类型,可能人家就是用的类型说明给数据类型取了个别名.typedef struct { char sex; int age; } student; int main() { //类型说明 typedef int xx;//定了一个新的类型 xx (其实就是int类型) int i = 10; xx j = 100; printf("int i = %d\n",i); printf("xx j = %d\n",j); // typedef student stu;//定一个类stu类型 -->student student stu; stu.age=10; stu.sex='m'; printf("age = %d\n",stu.age); printf("sex= %c\n",stu.sex); system("pause");//暂停 让cmd窗口不消失 } " data-snippet-id="ext.22b6bb2a9191d2b8479b6224801d200e" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> typedef struct { char sex; int age; } student; int main() { //类型说明 typedef int xx;//定了一个新的类型 xx (其实就是int类型) int i = 10; xx j = 100; printf("int i = %d\n",i); printf("xx j = %d\n",j); // typedef student stu;//定一个类stu类型 -->student student stu; stu.age=10; stu.sex='m'; printf("age = %d\n",stu.age); printf("sex= %c\n",stu.sex); system("pause");//暂停 让cmd窗口不消失 }
- 预处理指令
预处理指令主要包括:#define
#error
#if
#else
#elif
#endif
#ifdef
#ifndef
#undef
#line
#pragma
#define
#define指令是一个宏定义指令, 定义的一般形式是:
#define 宏替换名字符串(或数值)
由#define指令定义后, 在程序中每次遇到该宏替换名时就用所定义的字符
串(或数值)代替它。
例如: 可用下面语句定义TRUE表示数值1, FALSE表示0。 (C里面没有true和false的概念,只有大于0(true)和小于等于零(false))
#define TRUE 1
#define FALSE 0
一旦在源程序中使用了TRUE和FALSE, 编译时会自动的用1和0代替。
注意:
在宏定义语名后没有”;”
在Turbo C程序中习惯上用大写字符作为宏替换名, 而且常放在程序开头。
宏定义还有一个特点, 就是宏替换名可以带有形式参数, 在程序中用到
时, 实际参数会代替这些形式参数。
//通过define 定义TRUE 1 FALSE 0 #define TRUE 1 #define FALSE 0 int main(){ if(FALSE){ printf("大于零"); }else{ printf("小于等于0"); } system("pause");//暂停 让cmd窗口不消失 } " data-snippet-id="ext.0efcc25d2b78a7c14c55ad06974899b4" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> //通过define 定义TRUE 1 FALSE 0 #define TRUE 1 #define FALSE 0 int main(){ if(FALSE){ printf("大于零"); }else{ printf("小于等于0"); } system("pause");//暂停 让cmd窗口不消失 }
利用宏定义,定义一个全局的方法:
#define Max(x,y)(x>y)?x:y int main(){ /** float x = 101; float y = 119; float max = Max(x,y); printf("max = %f",max); */ int gg = 22; int mm = 20; int max = Max(gg,mm); printf("max = %d",max); system("pause");//暂停 让cmd窗口不消失 } " data-snippet-id="ext.d8e4e3cba34e5eff9c38d43e04d13031" data-snippet-saved="false" data-codota-status="done">[code]#include<stdio.h> #define Max(x,y)(x>y)?x:y int main(){ /** float x = 101; float y = 119; float max = Max(x,y); printf("max = %f",max); */ int gg = 22; int mm = 20; int max = Max(gg,mm); printf("max = %d",max); system("pause");//暂停 让cmd窗口不消失 }
我们可以看到在宏定义的方法参数里我们不需要指定数据类型,(这难道就是泛型的原型吗?哈哈)
我的博客网站http://huyuxin.top/欢迎大家访问,评论!
相关文章推荐
- C语言基础知识汇总
- C语言基础知识汇总
- Golang 入门系列(三)Go语言基础知识汇总
- 黑马程序员_c语言基础知识大汇总
- C语言基础-部分基础理论知识汇总
- 基于JVM的动态语言Groovy 基础知识汇总
- java基础知识,你可能找不到的 基础dos语言汇总
- C#语言基础常见问题汇总(1)
- 无线标记语言(WML)基础之基本知识
- linux操作系统下c语言编程入门 -- (1)基础知识
- 第二讲 Java语言基础知识
- 汇编语言的基础知识标识符和表达式
- Linux下C语言编程基础知识
- Java 语言基础知识(一)
- Linux系统下C语言编程基础知识介绍
- 路由器基础知识点汇总学习
- C语言基础知识
- 路由器基础知识点汇总学习
- C/C++语言基础知识总结
- linux程序设计入门----基础知识:linux下C语言编程基础知识