c的基础知识点都在这里可按照目录查找
1、C语言32个关键字
auto ：声明自动变量 一般不使用 double ：声明双精度变量或函数 int： 声明整型变量或函数 struct：声明结构体变量或函数 break：跳出当前循环 else ：条件语句否定分支（与 if 连用） long ：声明长整型变量或函数 switch :用于开关语句 case：开关语句分支 enum ：声明枚举类型 register：声明积存器变量 typedef：用以给数据类型取别名（当然还有其他作用） char ：声明字符型变量或函数 extern：声明变量是在其他文件正声明（也可以看做是引用变量） return ：子程序返回语句（可以带参数，也看不带参数） union：声明联合数据类型 const ：声明只读变量 float：声明浮点型变量或函数 short ：声明短整型变量或函数 unsigned：声明无符号类型变量或函数 continue：结束当前循环，开始下一轮循环 for：一种循环语句(可意会不可言传） signed：生命有符号类型变量或函数 void ：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用） default：开关语句中的“其他”分支 goto：无条件跳转语句 sizeof：计算数据类型长度 volatile：说明变量在程序执行中可被隐含地改变 do ：循环语句的循环体 while ：循环语句的循环条件 static ：声明静态变量 if:条件语句2、基本符号及其用法
注释： 多行注释 /*..........*/ 单行注释 // 逻辑运算符： ||：两边的条件只要有一个为真，其结果就为真；两边都为假，才假。 &&：两边的条件只要有一个结果为假，其结果就为假；两边都为真才真。 位运算符： &：按位与 |：按位或 ^：按位异或 ~：取反 >>：右移 <<：左移 自加自减： ++i，--i：在前时先自加或自减，然后再做别的运算。 i++，i--：在后时先做别的运算，然后再自加或自减。3、static、extern、const的用法
static： （1）static：修饰变量 i. 静态全局变量，作用域仅限于变量被定义的文件中，其他文件即使用extern 声明也没法使用他； ii. 静态局部变量，在函数体里面定义的，就只能在这个函数里用了，同一个文档中的其他函数也用不了； （2）Static：修饰函数 i. 对函数的作用域仅局限于本文件，不同的人 编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。 const： （1）const 修饰的只读变量必须在定义的同时初始化； （2）修饰一般变量int const i=0;或const int i=0; （3）修饰数组int const a[5]={1, 2, 3, 4, 5}; 或 const int a[5]={1, 2, 3, 4, 5}; （4）修饰指针 i. const int *p; //const 修饰*p,p 是指针，*p 是指针指向的对象，不可变 ii. int const *p; //const修饰*p,p 是指针，*p 是指针指向的对象，不可变 iii. int *const p; //const修饰p，p 不可变，p 指向的对象可变 iv. const int *const p; //前一个const 修饰*p,后一个const 修饰p，指针p 和p 指向的对 象都不可变 （5）修饰函数的参数，当不希望这个参数值被函数体内意外改变时使用， 例如： void Fun(const int i); （6）const 修饰符也可以修饰函数的返回值，返回值不可被改变。 例如： const int Fun (void); （7）在另一连接文件中引用const 只读变量： extern const int i; //正确的声明 extern const int j=10; //错误！只读变量的值不能改变 extern： extern 可以置于变量或者函数前，以标示 变量或者函数的定义在别的文件中，下面的代码用到的这些变量或函数是外来的，不是本文 件定义的，提示编译器遇到此变量和函数时在其他模块中寻找其定义。 三种基本的数据模型：按照数据结构类型的不同，将数据模型划分为层次模型、网状模型和关系模型。4、枚举类型的使用方法举例
//如分别用一个常数表示不同颜色：
enum Color
{
GREEN = 1,
RED,
BLUE,
GREEN_RED = 10,
GREEN_BLUE
}ColorVal；
//其中各常量名代表的数值分别为：
GREEN = 1
RED = 2
BLUE = 3
GREEN_RED = 10
GREEN_BLUE = 11 5、怎样避免野指针？
定义指针变量的同时好初始化为NULL，用完指针之后也将指针变量的值设置为NULL。6、 栈、堆和静态区的区别？
静态区：保存自动全局变量和static 变量（包括static 全局和局部变量）。静态区的内 容在总个程序的生命周期内都存在，由编译器在编译的时候分配。 栈：保存局部变量。栈上的内容只在函数的范围内存在，当函数运行结束，这些内容也 会自动被销毁。其特点是效率高，但空间大小有限。 堆：由malloc 系列函数或new 操作符分配的内存。其生命周期由free 或delete 决定。 在没有释放之前一直存在，直到程序结束。其特点是使用灵活，空间比较大，但容易出错。7、malloc函数的使用方法
函数原型：(void *)malloc(int size) malloc 函数的返回值是一个void 类型的指针，参数为int 类型数据，即申请分配的内存大小，单位是byte；
//例：
char *p = (char *)malloc(100);
// 在堆上分配了100 个字节内存，返回这块内存的首地址
//注：使用malloc之后要及时使用free函数释放内存空间
void free(void *FirstByte)： 8、段错误的原因？
段错误是指访问的内存超出了系统给这个程序所设定的内存空间，例如访问了不存在的内存地址、访问了系统保护的内存地址、访问了只读的内存地址、栈溢出等等情况9、什么是内存泄漏（memory leak）？
指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。 1.内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。 2. 对于C和C++这种没有Garbage Collection 的语言来讲，我们主要关注两种类型的内存泄漏： 堆内存泄漏（Heap leak）。对内存指的是程序运行中根据需要分配通过malloc,realloc new等从堆中分配的一块内存，再是完成后必须通过调用对应的 free或者delete 删掉。如果程序的设计的错误导致这部分内存没有被释放，那么此后这块内存将不会被使用，就会产生Heap Leak.malloc\realloc —— free
new \new[] ———- delete \delete[]10、typedef和#define的使用
typedef常用来定义一个标识符及关键字的别名，它是语言编译过程的一部分，单它并不实际分配内存空间，如：typedef int INT;typedef int ARRY[10]; type (int *) pINT; #define为一宏定义语句，通常用它来定义常量（包括无参量与带参量），以及用来实现那些“表面和善，背后一长串”的宏，它本身并不在编译过程中进行，而是在预处理过程中就已经完成了，但也因此难以发现潜在的错误以及其他代码维护问题。
#define INT int;
#define Add(a,b) ((a)+(b));- 11、几种循环的使用方法：利用循环打印1到9；
//For循环
int i=0;
for(i=0;i<10;i++)
{
printf(“%d\n”,i);
}
//while循环
int i=0;
While(i<10)
{
printf(“%d\n”,i);
i++；
}
//do-while循环
int i=0;
do
{
printf(“%d\n”,i);
i++;
}while(i>9);12、sizeof 是关键字不是函数！
13、函数的定义及优点
把一些功能相对来 说能成为一个整体的代码放到一起打包，通过一些数据接口和外界通信。这就是函数的由来。 降低复杂性、避免重复代码段、限制改动带来的影响、隐含顺序、改进性能进行集中控制、隐含数据结构、隐含指针操作、隐含全局变量。14、指针函数和函数指针
1、指针函数是指带指针的函数，即本质是一个函数。 函数返回类型是某一类型的指针类型标识符 *函数名(参数表) int *f(x，y); 2、函数指针是指向函数的指针变量，即本质是一个指针变量。 int (*f) (int x); 声明一个函数指针 f=func; 将func函数的首地址赋给指针f15、形参和实参区别：
1、函数的形参列于函数声明中，在函数定义的函数体内使用。当调用函数时，形参是一类将要被填充的空白或是占位符。 2、实参是用来填充形参的。当编写函数调用时，实参列在函数名后面的括号里。执行函数调用时，实参被传递给形参。 3、传值调用和引用调用指的是用于参数传递过程的一种机制。在传值调用中，只使用了实参的值。传值调用机制中，形参是一个局部变量，其初始值为相应实参的值。在引用调用机制中，以实参变量取代形参，因此任何发生在形参上的改变实际上都发生在实参变量上。16、怎样避免函数传参问题？
要使用函数一定要有，函数的声明，函数的定义，函数的调用 函数声明在文件的首部，或者声明在对应的.h文件中； 函数定义时的函数类型、调用时函数值的类型和函数的返回值类型保持一致； 实参和形参在数量上、类型上、顺序上应严格一致；17、函数的的传参方式？
1、值传递：在传递时会自动将传入的实参复制一份，只将实参的副本传入函数，在函数中对参数的修改不会影响到原变量。（此种传递方式需要注意，在将对象当作参数时的复制构造函数的问题）优点： 因为在函数中只是对变量的副本进行操作，所以不会出现误操作导致原变量被非法修改的问题。 2、地址传递：将变量的地址当作参数传入函数，在函数中通过地址来操作变量，在函数中对变量的修改会影响到传入的原变量。 优点：地址传递直接通过地址修改变量，在需要通过函数改变传入参数状态的场合很常用。对地址的操作也是c++学习的重点。 3、引用传递：将变量的引用当作参数传入函数，在函数中通过引用来操作变量，在函数中对变量的引用的修改会影响到原变量 优点：引用传递的作用类型与地址传递相似，使用它的目的主要是为了两点： 1. 安全性，在给函数传递对象的时候，如果使用地址传递，则有可能会在函数中出现误操作导致未知问题。 2. 语法简洁，使用引用传递时，在函数中可以直接将参数以局部变量的形式出现，避免了指针的使用。更重要的方面在于，在使用运算符重载时，可能会对 * 之类的运算符进行重载，如果使用地址传递的话，可能会出现很多反人类的代码，可读性很差，所以c++加入了引用传递这一特性。 3.提高效率18、读文件和写文件模板
读文件模板，返回读取链表的头节点
stuNode readd1()
{
FILE * fp;
fp=fopen("stu.txt1","r");
if(fp==NULL)
return NULL;
stuNode temp,head;
head=(stuNode)malloc(LEN);//分配空间malloc()函数
head->next=NULL;
temp=(stuNode)malloc(LEN);//分配空间malloc()函数
while((fread (temp,LEN,1,fp))>0)
{
temp->next=head->next;
head->next=temp;
temp=NULL;
temp=(stuNode)malloc(LEN);
}
fclose(fp);
fp=NULL;
return head;
}
//写文件函数模板，传入链表头节点
void save1(stuNode head)
{
FILE * fp;
int ret;
stuNode p;
p=head->next;
if((fp=fopen("stu.txt1","w"))==NULL)
{
printf("打开文件失败\n");
return;
}
while(p!=NULL)
{
ret=fwrite(p,LEN,1,fp);
if(ret<=0)
perror("the link is empty\n");
p=p->next;
}
printf("文件保存成功->>>>>>\n");
fclose(fp);
sleep(1);
}19、用变量 a 给出下面的定义
a) 一个整型数（An integer） b) 一个指向整型数的指针（A pointer to an integer） c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer） d) 一个有 10 个整型数的数组（An array of 10 integers） e) 一个有 10 个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers） f) 一个指向有 10 个整型数数组的指针（A pointer to an array of 10 integers） g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer） h) 一个有 10 个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ） 答案是： a) int a; // An integer b) int *a; // A pointer to an integer c) int **a; // A pointer to a pointer to an integer d) int a[10]; // An array of 10 integers e) int *a[10]; // An array of 10 pointers to integers f) int (*a)[10]; // A pointer to an array of 10 integers g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an intege20、数组的初始化方法
完全初始化：int a[5]={1,2,3,4,5}; 不完全初始化：int a[5]={1,2,3}; 不写明数组大小的初始化：int a[ ]={1,2,3,4,5};21、队列和栈的区别？
队列先进先出，栈后进先出22、如何引用一个已经定义过的全局变量？
可以用引用头文件的方式，也可以用 extern 关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变量，假定你将那个变量写错了，那么在编译期间会报错，如果你用 extern 方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。23、do……while 和 while……do 有什么区别？
前一个循环一遍再判断，后一个判断以后再循环。24、全局变量可不可以定义在可被多个.C 文件包含的头文件中？
可以，在不同的 C 文件中以 static 形式来声明同名全局变量。 可以在不同的 C 文件中声明同名的全局变量，前提是其中只能有一个 C 文件中对此变量赋初值，此时连接不会出错。25、结构与联合有和区别？
(1). 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选 中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。 (2). 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成 员赋值是互不影响的26、分别写出 BOOL,int,float,指针类型的变量 a 与“零”的比较语句。
BOOL : if ( !a ) or if(a)
int : if ( a == 0)
float : const EXPRESSION EXP = 0.000001 if ( a < EXP && a >-EXP)
pointer : if ( a != NULL) or if(a == NULL)- 31、交换两个变量的值，不使用第三个变量。 即 a=3,b=5,交换之后 a=5,b=3;
有两种解法, 一种用算术算法, 一种用^(异或)
a = a + b;
b = a - b;
a = a - b;
or
a = a^b;// 只能对 int,char..
b = a^b;
a = a^b;
Or
a ^= b ^= a;27、不能做switch()的参数类型？
switch的参数不能为实型28、static函数与普通函数有什么区别？
static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝29、static有什么用途？
限制变量的作用域（static全局变量） 设置变量的存储域（static局部变量）30、const 有什么用途？
可以定义const 常量 const 可以修饰函数的参数、返回值，甚至函数 的定义体。被const 修饰 的东西都受到强制保护，可 以预防意外的变动，能提高程序的健壮性。31、头文件中的ifndef/define/endif干什么用？
防止该头文件被重复引用32、数组和链表的区别？
数组：数据顺序存储，固定大小； 链表：数据可以随机存储，大小可动态改变33、引用与指针有什么区别？
1) 引用必须被初始化，指针不必。 2) 引用初始化以后不能被改变，指针可以改变所指的对象。 3) 不存在指向空值的引用，但是存在指向空值的指针。34、四字节对齐？
1.数据类型自身的对齐值：对于char型数据，其自身对齐值为1，对于short型为2，对于int,float类型，其自身对齐 值为4，对于double型，其自身对齐值为8，单位字节。
2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。
3.指定对齐值：#pragma pack (value)时的指定对齐值value。
4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值。35、下列程序的输出结果
unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;
请问 p1+5= ;
p2+5= ;
//【标准答案】0x801005、0x81002036、#include<file.h> 与 #include "file.h"的区别？
前者是从 Standard Library 的路径寻找和引用 file.h，
后者是从当前工作路径搜寻并引用 file.h37、结构与联合有和区别？
(1). 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选 中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。 (2). 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成 员赋值是互不影响38、指针数组和数组指针
指针数组：array of pointers，即用于存储指针的数组，也就是数组元素都是指针 数组指针：a pointer to an array，即指向数组的指针 还要注意的是他们用法的区别，下面举例说明。 int* a[4] 指针数组 表示：数组a中的元素都为int型指针 元素表示：*a[i] *(a[i])是一样的，因为[]优先级高于* int (*a)[4] 数组指针 表示：指向数组a的指针 元素表示：(*a)[i]39、运算符&和*的含义和用法
&是取地址运算符，*是间接运算符。 &a 的运算结果是一个指针，指针的类型是 a 的类型加个*，指针所指向的类型是 a 的 类型，指针所指向的地址嘛，那就是 a 的地址。 *p 的运算结果就五花八门了。总之*p 的结果是 p 所指向的东西，这个东西有这些特 点：它的类型是 p 指向的类型，它所占用的地址是 p所指向的地址。40、说明下列指针的类型，和指针指向的类型
(1)int*ptr;//指针的类型是 int*，指向的类型是int; (2)char*ptr;//指针的类型是 char*,指向的类型是char; (3)int**ptr;//指针的类型是 int**,指向的类型是int*; (4)int(*ptr)[3];//指针的类型是 int(*)[3],指向的类型是int()[3]; (5)int*(*ptr)[4];//指针的类型是 int*(*)[4],指向的类型是int*()[4]。 注：把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型； 把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。41、*P++自增P还是自增P指向的变量？
后缀++和——操作符本质上比前缀一元操作符优先级高，因此*P++和*P(++)等价，自增P并返回P自增之前所指向的值。要自增P指向的值，则使用(*p)++,如果副作用的顺序无关紧要也可以使用++P。42、c语言中 int *p = NULL 和 *p = NULL 有什么区别？
1. int *p = NULL; 代表定义一个指向整型变量的指针p，然后p的值设为NULL,也就是设为0；用另一种方式说，就是对一个刚定义的指向整型变量的指针，赋初始值，让其指向0地址。 2. *p = NULL; 代表对一个由指针p指向的变量（什么类型，不知道），赋值为0，是将那个变量赋值为0。43、分析下列P值
int p; //这是一个普通的整型变量
int *p; //首先从 P 处开始,先与*结合,所以说明 P 是一个指针,然后再与 int 结合,说明指针所指向的内容的类型为 int 型.所以 P 是一个返回整型数据的指针；
int p[3]; //首先从 P 处开始,先与[]结合,说明 P 是一个数组,然后与 int 结合,说明数组 里的元素是整型的,所以 P 是一个由整型数据组成的数组。
int *p[3]; //首先从 P 处开始,先与[]结合,因为其优先级比*高,所以 P 是一个数组,然后再与*结合,说明数组里的元素是指针类型,然后再与 int 结合,说明指针所指向的内容的类型是整型的,所以P 是一个由返回整型数据的指针所组成的数组
int (*p)[3]; //首先从 P 处开始,先与*结合,说明 P 是一个指针，然后再与[]结合(与"()"这步可以忽略,只是为了改变优先级),说明指针所指向的内容是一个数组,然后再与int 结合,说明数组里的元素是整型的.所以 P 是一个指向由整型数据组成的数组的指针
int **p; //首先从 P 开始,先与*结合,说是 P 是一个指针,然后再与*结合,说明指针所指向的元素是指针,然后再与 int 结合,说明该指针所指向的元素是整型数据.由于二级指针以及更高级的指针极少用在复杂的类型中,所以后面更复杂的类型我们就不考虑多级指针了,最多只考虑一级指针.
int p(int); //从 P 处起,先与()结合,说明 P 是一个函数,然后进入()里分析,说明该函数有一个整型变量的参数然后再与外面的 int 结合,说明函数的返回值是一个整型数据；
Int (*p)(int); //从 P 处开始,先与指针结合,说明 P 是一个指针,然后与()结合,说明指针指向的是一个函数,然后再与()里的int 结合,说明函数有一个 int 型的参数, 再与最外层的int 结合,说明函数的返回类型是整型,所以 P 是一个指向 有一个整型参数且返回类型为整型的函数的指针；
int *(*p(int))[3]; //可以先跳过,不看这个类型,过于复杂从 P 开始,先与()结合,说明 P 是一个函数,然后进入()里面,与 int 结合,说明函数有一个整型变量参数,然后再与外面的*结合,说明函数返回的是一个指针,,然后到最外面一层,先与[]结合,说明返回的指针指向的是一个数组,然后再与*结合,说明数组里的元素是指针,然后再与 int 结合,说明指针指向的内容是整型数据.所以 P 是一个参数为一个整数据且返回一个指向由整型指针变量组成的数组的指针变量的函数。44、c和c++中的struct有什么不同？
c和c++中struct的主要区别是c中的struct 不可以含有成员函数，而c++中的struct可以。c++中 struct和class的主要区别在于默认的存取权限不同， struct默认为public，而class默认为private。45、关键字volatile有什么含意?并给出三个不同的例子。
一个定义为volatile的变量是说这变量可 能会被意想不到地改变，这样，编译器就不会去假设 这个变量的值了。精确地说就是，优化器在用到这个 变量时必须每次都小心地重新读取这个变量的值，而 不是使用保存在寄存器里的备份。 下面是volatile变量 的几个例子： 1). 并行设备的硬件寄存器（如：状态寄存器）； 2). 一个中断服务子程序中会访问到的非自动变量 (Non-automatic variables)； 3). 多线程应用中被几个任务共享的变量。46、Heap与stack的差别
Heap是堆，stack是栈。 Stack的空间由操作系统自动分配/释放，Heap上的空 间手动分配/释放。 Stack空间有限，Heap是很大的自由存储区 C中的malloc函数分配的内存空间即在堆上,C++中对 应的是new操作符。 程序在编译期对变量和函数分配内存都在栈上进行,且 程序运行过程中函数调用时参数的传递也在栈上进行。47、C语言运算符优先级表（由上至下，优先级依次递减）
运算符 结合性 () [] -> . 自左向右 ! ~ ++ -- - (type) * & sizeof 自右向左 * / % 自左向右 + - 自左向右 << >> 自左向右 < <= > >= 自左向右 == != 自左向右 & 自左向右 ^ 自左向右 | 自左向右 && 自左向右 || 自左向右 ?: 自右向左48、实现strcmp函数
int mystrcmp(constchar* str1, const char* str2)
{
assert((str1 != NULL) && (str2 != NULL));
int ret = 0;
while (!(ret = *(unsigned char*)str1 -*(unsigned char*)str2) && *str2)
{
str1++;
str2++;
}
if (ret > 0)
ret = 1;
else if (ret < 0)
ret = -1;
return ret;
}49、请编写一个C 函数，该函数将一个字符串逆序。
void AntitoneValue(char* father, char* child)
{
int i=0;
char source[100];
int j = 0;
while(father[j]) //放入source，[j]为长度
{
source[j] = father[j];
j++;
if(j> 99)
return;
}
source[j] = '\0';
for(i=0; i<j; i++)
child[i] = source[j-i-1]; //反序
child[i] = '\0';
} 