C语言随笔 转自子衿-青青

用多了java，python，再用起C语言来很不习惯。这里记录C语言一些零散的东西吧，慢慢更新

1）C语言，函数或块中一个变量名只能定义一次，且定义在开头（定义在开头好像没那么严格）

[objc] view plain copy

1. #include <stdio.h>  
2.   
3. int main(void){//下面的例子可行  
4.   int fahr = 1;  
5.   {  
6.       int fahr = 2;  
7.   }  
8.   printf("111\n");  
9.   int a = 3;  
10. }  

[objc] view plain copy

1. #include <stdio.h>  
2.   
3. int main(void){ //重复定义，报错  
4.   int fahr = 1;  
5.   int fahr = 2;  
6.   
7.   printf("111\n");  
8.   int a = 3;  
9. }  

[objc] view plain copy

1. #include <stdio.h>  
2.   
3. int main(void){ //重复定义，报错  
4.   
5.   
6.   {  
7.       int fahr = 1;  
8.       int fahr = 2;  
9.   
10.   }  
11.   
12.   printf("111\n");  
13.   int a = 3;  
14. }  

2）求余运算符%，只能用于整型数据，不能用于实型数据

3）int fahr = 1;  printf("hi\n", fahr);  缺少格式控制符（%d），此处只输出hi，不输出fahr的值

4）printf格式控制%f：默认小数点后保留6位小数；

         4.1）位数不够，补0（也不一定，因为实型数据的存储本身就不准确，还有有效数字位数的问题）

         

[objc] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. int main()  
5. {  
6.     float b = 123.4;//位数不够的情况  
7.     printf("%f\n", b);//我这里输出的是123.400002，不同编译器可能不同  
8.     return 0;  
9. }  

4.2）位数超过，四舍五入

[objc] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. int main()  
5. {  
6.     float b = 1.23456789;  
7.     printf("%f\n", b);//我这里输出是1.234568  
8.     return 0;  
9. }  

4.3）有效数字（从第一个不为0的数字开始）6-7位

[objc] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. int main()  
5. {  
6.     float a = 123456789.123456;  
7.     printf("%f\n", a);//我这里输出是123456792.000000  
8.     return 0;  
9. }  

可以看到超过有效数字范围后，值不准确了

4.4）%-n.mf   :    - 左对齐（如，12.67空格），n 总宽度（整数+小数点+小数所占的位置）；若 - 出现，n必须出现（如%-6.2f）;不加-，右对齐（如，空格12.67）

5）scanf

5.1）不要出现转义字符，如scanf("%d\n", &x);  这里出现了转义字符\n

5.2）不要忘记&，如scanf("%d",x); 忘记了&

5.3）若有普通字符，在输入数据时需要原样输入。如scanf("x=%d", &x);  在输入时就必须 x=7 这样子输入，不是只输入7

5.4）不允许像输出一样确定位数，如scanf("%.2f", &x);不会报错，但是你再把x值输出一下，就知道有问题了

[objc] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. int main()  
5. {  
6.     float x;  
7.     scanf("%.2f", &x);  
8.     printf("%.2f",x);  
9.     return 0;  
10. }  

6）在嵌套if-else语句中，如果内嵌的if省略了else部分，可能在语义上产生二义性。

if(表达式1)

           if(表达式2) 语句1;

else    /*与哪个if匹配？*/

if(表达式3) 语句2;

        else 语句3;

else 和 if 的匹配准则：else与最靠近它的、没有与别的else匹配过的if相匹配

所以虽然第一个else与第一个if书写对齐，但它与第二个if对应。。如果要和第一个if匹配，应该如下

if(表达式1){

           if(表达式2) 语句1;

}

else 

if(表达式3) 语句2;

        else 语句3;

7）switch-case结构中，注意是否有break

[objc] view plain copy

1. int main(void){  
2.  int x = 1, a = 0, b = 0;  
3.  switch(x){  
4.    case 0: b++;  
5.    case 1: a++;  
6.    case 2: a++; b++;  
7.  }  
8.  printf("a=%d, b=%d\n", a,b);// a=2, b=1  
9.  return 0;  
10. }  

8）与逻辑表达式！x等价的C语言表达式是 x==0

9）循环次数已知，使用for语句；

循环条件在进入循环时明确，用while语句；

循环条件需要在循环体中明确，用do-while语句

10）全局变量

10.1）定义：定义在函数外而不属于任何函数的变量称为全局变量。

10.2）作用范围：从定义开始到程序所在文件的结束，它对作用范围内所有的函数都起作用

10.3）定义格式：一般全局变量定义在程序的最前面，即第一个函数的前面

10.4）全局变量和某函数的局部变量同名时，局部变量起作用；

          函数的局部变量与复合语句的局部变量同名时，以复合语句为准

11）变量生存周期

一旦在程序中定义变量，计算机在执行过程中就会根据变量类型分配相应的内存单元供变量保存数据

也就是说函数未被调用之前，其局部变量并未分配存储单元，只有当函数被调用时，其形参和局部变量才被分配相应存储单元；一旦函数调用结束返回主调函数，在函数中定义的所有形参和局部变量将不复存在，相应的存储单元由系统收回。

变量从定义开始分配存储单元，到运行结束存储单元被回收，整个过程称为变量生存周期

从程序执行的开始到整个程序的结束，全局变量都有效，对应的存储单元都保持，因此它的生存周期为整个程序执行周期

12）变量存储的内存分布

C语言 把保存所有变量的数据区分为动态存储区和静态存储区。

动态存储区是使用堆栈来管理的，适合函数动态分配与回收存储单元。动态存储区中的变量按函数组织，main()函数的real1与complex_add()函数的real1分属不同单元，有各自的内存单元

静态存储区相对固定，管理较简单，用于存放全局变量和静态（局部）变量

13）静态局部变量

 13.1）定义格式： static 类型名 变量表

 13.2）存放在静态存储区，生存周期会持续到程序结束。由于存储单元被保留，一旦含有静态局部变量的函数被再次调用，则静态局部变量会被重新激活，上一次函数调用后的值仍然保存着，可供本次调用继续使用

 13.3）局部变量未赋初值，其存储单元中将是随机值。

 全局变量若未赋初值，则自动赋0

 而静态局部变量定义时未赋初值，系统自动赋0，并且赋初值只在函数第一次调用时起作用，以后调用都按前一次调用保留的值使用。因为静态局部变量的生存周期始于函数的第一次调用，函数被再次调用时，此静态局部变量单元已经存在，计算机不会再次为它分配单元，赋初值也不再发生

13.4）静态局部变量与全局变量

共同点是生存周期贯穿整个程序执行过程

区别在于作用范围不同，全局变量可作用于所有函数，静态局部变量只能用于所定义的函数

14）在C语言程序中，若对函数类型未加显式说明，则函数的默认类型为int

15）实参与形参

15.1）实参可以是常量、变量、表达式，可以是任何类型，只要有确定的值

15.2）形参只能是变量

16）

[objc] view plain copy

1. #include <stdio.h>  
2. //#include <stdlib.h>  
3. //#include <math.h>  
4.   
5. int main()  
6.  {  
7.   long a = 0x12345678L;//16进制，共4*8=32位  
8.   short b;  
9.   b = a;  
10.   printf("%x", b);// 输出 5678，共4*4=16位  
11.   return 0;  
12.  }  

b所分配的内存地址放不下这个数，所以只取b的低字节部分5678，因而输出结果也就是5678

17）数据类型自动转换规则

[objc] view plain copy

1. #include <stdio.h>  
2. //#include <stdlib.h>  
3. //#include <math.h>  
4.   
5. int main()  
6.  {  
7.   int a = -1;  
8.   unsigned b = 1;  
9.   if(a > b){  
10.     printf("1\n");//输出此句  
11.   }else{  
12.     printf("0\n");  
13.   }  
14.   return 0;  
15.  }  

原因：a转换成unsigned型，值为2^32-1，明显大于b的值1，所以a > b

17.1）数据类型自动转换规则（非赋值运算时）：

先进行水平方向的转换，若水平转换后数据类型仍不相同，再进行垂直方向的转换，自动转换成其中级别最高的类型

例如：char 和short相加，都自动转成int再相加；若再减个double，则前面相加的结果int转换成double，再相减

17.2）赋值运算时，将赋值号右侧表达式的类型自动转换成赋值号左侧变量的类型

17.3）强制类型转换

（类型名）表达式

如： (int) 3.8， (double) i 之类

强制类型转换运算符的优先级较高，与自增运算符++相同，它的结合性是从右到左。

如：(int) 3.8 + 1.3 = 4.3      (int) (3.8+1.3) = 5       (double) (5/2) = 2.0       (double) 5 / 2 = 2.5 

无论自动类型转换，还是强制类型转换，都是对数据类型进行临时转换，并没有改变数据的定义。如表达式(double) i的类型是double，而i的类型还是原来的，并没有改变

18）运算符的结合性

单目运算符（!，++，--，*(指针)，-(负号)），三目运算符（?:），赋值运算符（=，+=，-=， *=，/=，%=）的结合性是从右往左，其他是从左往右

只有同优先级的运算符才具有结合性，如 *  / 是同一级别的

例如： a = b = c，等价于 a = (b = c)

19）<<（左移）, >>（右移）并不改变原来的值

a = 2;      b = ａ<< 1    b的值为4，而a的值还是2

20）位运算符（&，|，^，~，<<，>>）所操作的操作数只能是整型或字符型的数据以及它们的变体

21) 

设int a=5,b=6,表达式（++a==b--）？++a:--b的值是 7

提示         ？：等价于if...else...

22）   

23）

24）数组：一组相同类型数据的有序集合。

数组中的元素在内存中连续存放，用数组名和下标可以唯一地确定数组元素

定义数组后，系统根据数组中元素的类型及个数在内存中分配一段连续的存储单元

数组名是一个地址常量，存放数组内存空间的首地址，不允许修改，例如：int a[3];     a = {10,11,12}就是错的

数组长度是一个常量

24.1）#define M 10

   int a[M]       这种可以     int a[M-2] 也可以

24.2）int n = 10;   int a[n]       这种不行

24.3）数组部分初始化，int a[5] = {1,2} 只有前两个元素被初始化了；若全部初始化，则 int b[] = {4,5,6}也行，

int c[][2] = {1,2,3,4}

25）字符串由有效数字和字符串结束符‘\0’组成

字符串“Happy”的有效长度是5，存储它的数组的长度至少是6，可以作为整体输出

第一个'\0'之后的其他数组元素与该字符串无关

[objc] view plain copy

1. #include <stdio.h>  
2.   
3. int main()  
4.  {  
5.   char s[6] = {'H', 'a', 'p', 'p', 'y', '\0'};  
6.   // char s[6] = "Happy";  
7.   // char s[6] = {"Happy"};  
8.   printf("%d\n", strlen(s));//strlen返回字符串的有效长度  
9.   printf("%s\n", s);//字符串可以作为整体输出  
10.   
11.   char a[6] = {'H', 'a', 'p', 'p', 'y'};//数组位数足够，所以后面补'\0'，是个字符串  
12.   printf("%d\n", strlen(a));  
13.   
14.   char b[5] = {'H', 'a', 'p', 'p', 'y'};//数组位数不够，所以没有'\0',不是个字符串  
15.   printf("%d\n", strlen(b));//值不确定，它会一直往后找，直到找到第一个'\0'  
16.   
17.    
18.   char c[20] = {'H', 'a', 'p', 'p', 'y', '\0', 'N', 'e', 'w'};  
19.   printf("%d\n", strlen(c));//<span style="font-size:18px;">第一个'\0'之后的其他数组元素与该字符串无关</span>  
20.   printf("%s\n", c);  
21.  }  

26）指针变量（简称指针）：专门用来存放变量地址的变量

如果一个指针变量的值是另一个变量的地址，就称该指针变量指向那个变量

在定义指针变量时需要使用指针声明符*，但指针声明符并不是指针的组成部分。例如，定义int *p;说明p是指针变量，而不是*p

27）指针变量的类型不是指指针变量本身的类型，而是指它所指向的变量的数据类型。

指针变量自身所占的内存空间的大小和它所指向的变量数据类型无关，不同类型指针变量所占的内存空间大小都是相同的

28）int *p = 0;是将指针变量初始化为空指针，这里0是ASCLL字符NULL的值

29）指针名和数组名都代表内存地址，但是指针名是变量，数组名是常量

假设 int a[100], *p; 假设系统int型为2个字节，系统把编号为3000,3002,3004,......的内存字节作为数组元素a[0],a[1],......的地址

29.1）p = a; 等价于 p = &a[0]

29.2）p = a + 1; 等价于 p = &a[1] ; 都是第二个数组元素的起始地址，而不是第一个元素起始地址加1，加的是一个数据类型的长度； p++ , a+j 此类加的都是数据类型的长度； *(a+i) 等价于 a[i]

29.3）a = a + 1 非法，因为a是常量，不能有赋值操作

29.4）scanf("%d", a+j) 等价于 scanf("%d", &a[0] + j)       看清楚有无&

29.5）scanf("%d, &n)，把输入的值存储到变量n所在的内存单元里 

30）

[objc] view plain copy

1. void f(int a[], int n){  
2. //  
3. //函数内容。。。。。  
4. }  

我们可以用f(a,n)调用上面的函数，其中a是个数组名。那么f函数的形参a[]是怎样的呢？

函数被调用时，形参a被分配一个存储空间，值为实参数组的地址，也就是说不是又在内存中分配一个数组的空间，而是让形参a指向实参数组，这意味着函数f里面改变数组a里面的值（比如a[2] = 3），实参数组也确实被修改了

31）

[objc] view plain copy

1. #include <stdio.h>  
2.   
3. int main()  
4.  {  
5.      double a[2], *p, *q;  
6.      p = &a[0];  
7.      q = p+1;  
8.      printf("%d\n", q-p);//计算指针p和q之间的元素个数,也是实际内存的高低位  
9.      printf("%d\n", (int)q - (int)p);//计算指针p和q之间的字节数  
10.  }  

32）指针的强制类型转换

[objc] view plain copy

1. #include <stdio.h>  
2.   
3. int main()  
4.  {  
5.      charchar *p="abcdefgh", *r;  
6.      intint *q;  
7.      q=(intint *)p;//指针的强制类型转换  
8.      q++;//加的是一个数据类型的长度  
9.      r=(charchar *)q;  
10.      printf("%s\n", r);//输出efgh  
11.  }  

33）字符串和字符指针

33.1）字符串常量中的所有字符在内存中连续存放，它的起始地址代表了存放字符串常量首字符的存储单元的地址，被称为字符串常量的值

33.2）

[objc] view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3.   
4. int main()  
5.  {  
6.     char sa[] = "array";//把字符串存入数组，实际是内存汇总的字符串赋值一份存入数组所在的内存  
7.     charchar *sp = "point";//把字符串的起始地址赋给sp  //博客出bug了，显示了两个char,把它当成一个就好了  
8.       
9.     printf("%s\n", "string"+1);//输出tring，因为string的值是字符串常量的地址  
10.       
11.     sa = "hello"; //出错，原因是数组名是常量，不能赋值  
12.     strcpy(sa,"hello");//正确，数组sa被赋予新的值  
13.       
14.     *sp = "lol";//出错，原因是sp指向的是字符串，是常量，不能赋值  
15.     sp = "lol";//正确，指针sp指向新的字符串“lol”  
16.       
17.  }  

33.3）定义字符指针后，如果没有对它赋值，指针的值是不确定地，不能明确它所指向的内存单元。因此引用未赋值的指针，可能出现难以预料的结果

char *s; scanf("%s", s); 没有对指针赋值，却对s指向的单元赋值。如果该单元已分配给其他变量，其值就被这次输入改变了

char *s， str[20]; s = str;  scanf("%s", s);这样就不会有错误了

34）结构

34.1）结构的形式：

struct 结构名{

类型名结构成员名1;

类型名结构成员名2;

......

};

其中，struct是定义结构的关键字。它与结构名合起来共同组成结构类型名

34.2）结构变量的定义

struct student{

int num;

char name[10];

}s1, s2; //这种随便定义了变量s1和s2

struct student a[10];  //定义了一个结构变量数组

34.3）结构变量作为形参和实参

形参 void new_student(struct student students[]) 

实参 new_student(a) //a是上面的结构变量数组

34.4）结构变量成员的引用

例如 s1.num 和s1.name

34.5）结构变量的初始化

定义时就赋值 struct student s1 = {111, "zhang"};

一个成员一个成员赋值: s1.num = 111; s1.name = "zhang";

34.6）结构变量的整体赋值

s1 = s2; //只有相同结构类型的变量才可以直接赋值

34.7）结构数组的初始化

struct student a[10] = {{101, "li"}, {102,"liu"}}; //只初始化了前两个

34.8）结构数组的操作 

结构数组名[下标].结构成员名

例如 a[1].num

34.9）结构指针

struct student *p1; p = &s1;

结构指针的值实际上是结构变量的首地址，即第一个成员的地址

若struct student *p2; p2 = &a; 那么p2++，等价于a[1]

34.10）结构指针作为参数

形参 void update(struct student *p) 

实参 update(p1)//指针 

或者 update(s1) //结构变量

或者update(a)//结构数组

34.11）获取结构变量的成员

p1->num;

s1.num;

(*p1).num；

35）递归程序的设计

递归出口，即终止条件

递归表达式，如 fact(n) = n * fact(n-1)

36）宏

36.1）宏的定义

#define 宏名 宏定义字符串      例子： #define PI 3.1415

注意：宏名中间不要有空格（因为空格分隔了它和宏定义字符串），常用大写字母串

   宏定义字符串中间可以有空格，以回车做结束。。不要加分号，否则分号也算内容

 一行写不下怎么办，加反斜杠  #define STR "It AAAAAA \

                 BBBBBB"

解除宏定义，例子 #undef PI

36.2）带参数的宏定义

例子：

[objc] view plain copy

1. #include <stdio.h>  
2. #define MAX(a,b) a>b ? a : b  
3.   
4. int main()  
5.  {  
6.     int x,y;  
7.     scanf("%d%d", &x, &y);  
8.     x = MAX(x,y); //引用宏定义  
9.     printf("%d ", x);  
10.  }  

编译预处理后，上面的例子变成

[objc] view plain copy

1. int main()  
2.  {  
3.       
4.     ...  
5.     x = x>y ? x : y;  
6.     ...  
7.  }  

36.3）宏替换

#define SQR(x) x*x

要是 y = SQR(x+y)，那么就有问题了。。y = x+y * x+y。。。看到没有，不会先给你计算表达式的值，再把值传过去的。它是直接替换

所以怎么避免呢，加括号 #define SQR(x) (x)*(x)

36.4）复杂一点的宏

#define JH(a,b,t) {t=a; a=b; b=t;}

37）文件包含

37.1）格式：#include <文件名> 。。尖括号一般是系统文件。。直接在C系统include文件夹里面找

     #include "文件名"。。引号一般是自己定义的文件。。先在当前工作的文件夹找，找不到再去C系统的include文件夹

37.2）文件包含的作用

在编译时起作用，把包含的文件的代码替换过来。。常用于模块较多的情况

比如 

[objc] view plain copy

1. //这个文件叫aver_sort.c，里面的代码如下  
2. void average(struct student students[]){  
3. ...  
4. }  
5.   
6. void sort(struct student students[]){  
7. ...  
8. }  

[objc] view plain copy

1. #include <stdio.h>  
2. #include "aver_sort.c"  
3.   
4. int main()  
5.  {  
6.     ...  
7.     average(students);//直接调用 aver_sort.c 里面的函数  
8.     ...  
9.  }  

37.3）文件模块间的通信

37.31）外部变量

声明形式 extern 变量名表

全局变量只能在某个模块中定义一次，如果其他模块要使用该全局变量，需要通过外部声明

37.32）静态全局变量 static

将其作用范围限制在一个文件模块中。即使其他文件模块使用外部变量声明，也不能使用该变量

37.33）静态函数。。。作用范围也是在当前模块。。即使别的模块有同名函数也没关系，一样能过。。。C语言本身是不支持同名函数的

static 函数类型 函数名(参数表说明)

37.34）一个模块调用另一个模块的函数

extern 函数类型 函数名(参数表说明)。。通常extern可以省略

38）指针数组与二维指针

38.1）例子： char* color[5]  = {"red", "blue", "yellow", "green", "black"};

38.2）定义：指针数组是由指针变量构成的数组。也就是说color数组存放的是指针，而不是字符串

38.3）数组名color的类型是二级指针char**，它代表了数组首元素color[0]的首地址

38.4）color+k 指向color[k]，也就是说 *(color+k)和color[k]等价

38.5）数组元素color[k]的类型是char*，它指向一个字符串，也就是存放了字符串首字符的地址。color[k]+j指向该字符串首字符后第j个字符

也就是说 *(color[0])的值是个字符r，*(color[0]+2)的值是字符d

38.6）二级指针（指向指针的指针）

int a = 10;

int *p = &a;

int **pp = &p;

38.7） 二级指针操作指针数组

char **p;

p = color;

然后就可以操作了

38.8) 指针数组的赋值

定义时赋值就不说了，我们来看看其他情况

[objc] view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3.   
4. int main()  
5.  {  
6.     charchar *a[5];//指针数组  
7.     char b[10];  
8.     int i;  
9.     for(i=0; i<5; i++){  
10.        //一，scanf("%s", a[i]);//报错,原因是指针怎么能保存字符串呢  
11.        /*二，scanf("%s", b); 
12.              strcpy(a[i], b);报错，strcpy的参数不是指针吗，为什么又错了？因为并不知道a[i]指向的内存地址是什么 
13.        */  
14.        //三，可行  
15.        scanf("%s", b);  
16.        a[i] = (char*)malloc(sizeof(char)*10);//这个不也是指针吗？是的，但是知道了a[i]指向的内存地址是什么  
17.        strcpy(a[i], b);//为什么这个可以，因为malloc的原因  
18.     }  
19.   
20.  }  

38.9）指针数组和二维数组的区别

char ccolor[][7]  = {"red", "blue", "yellow", "green", "black"};

char *pcolor[] = {"red", "blue", "yellow", "green", "black"}:

二维数组必须定义列长度，会造成内存的浪费；而指针数组并不存放字符串，就没有这种问题了

39）字符串的输入输出

39.1）char str[20]; scanf("%s", str);//遇空格或回车结束，自动在输入数据后面加上'\0'构成字符串，但是空格或者回车还是在输入里面的，也就是说你再输入点什么，就会发现前面多了个空格或者回车，通常在scanf这一句后面加上getchar()吃掉空格或回车

39.2）gets(str);//遇回车结束，会把回车自动转换成"\0"，保存在输入数据的末尾，所以不需要getchar();

39.3）printf("%s", str); //输出

39.4）puts(str); //输出时遇“\0”自动转换成回车

40）指针作为函数的返回值

40.1）返回指针的函数一般都返回全局数据对象或主调函数中的数据对象的地址

原因是局部数据对象在函数返回时消亡，即使返回了一个地址，也找不到了

40.2）形如：char *match(char *s, char ch); //代表返回值的类型是字符指针

40.3）例子：

[objc] view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. charchar *match(charchar *s, char ch);  
4.   
5. int main()  
6.  {  
7.     char ch, str[80], *p=NULL;  
8.   
9.     printf("Please Input the string:\n");  
10.     scanf("%s", str);  
11.     getchar();  
12.     ch = getchar();  
13.     if((p = match(str, ch))!= NULL)  
14.      printf("%s\n", p);  
15.     else  
16.     printf("Not Found\n");  
17.     return 0;  
18.  }  
19.   
20. charchar *match(charchar *s, char ch){  
21.    while(*s != '\0'){  
22.       if(*s == ch)  
23.         return s;  
24.       else  
25.         s++;  
26.    }  
27.    return NULL;  
28. }  

41）指向函数的指针

41.1）函数名代表函数的入口地址，可以定义一个变量，接收函数的入口地址，让它指向函数，这就是函数指针。函数指针可以作为其他函数的参数

41.2）格式 类型名 （*变量名）（参数类型表），形如： int (*funptr) (int , int );

41.3）通过函数指针调用函数

例子，假设fun(x,y)已经定义，那么funptr = fun;  (*funptr)(3,5) 与 fun(3,5)的效果相同

使用函数指针时，要先赋值。赋值时，将一个函数名赋给函数指针，但该函数必须已经定义或声明，且函数返回值的类型和函数指针的类型要一致

41.4）函数指针或函数名，作为函数的参数

41.4.1）实参：函数名或已经赋值的函数指针

41.4.2）形参：函数指针，指向实参所代表函数的入口地址

41.4.3）例子：

[objc] view plain copy

1. #include <stdio.h>  
2. #include <math.h>  
3. double calc(double (*funp)(double), double a, double b); //梯形公式计算数值积分  
4. double f1(double x), f2(double x);  
5.   
6. int main()  
7.  {  
8.     double result;  
9.     double (*funp)(double);  
10.   
11.     result = calc(f1, 0,1);  
12.     printf("1: result=%.4f\n", result);  
13.   
14.     funp = f2;  
15.     result = calc(funp, 1, 2);  
16.     printf("2: result=%.4f\n", result);  
17.   
18.     return 0;  
19.  }  
20.   
21.  double calc(double (*funp)(double), double a, double b){  
22.     double z;  
23.     z = (b-a)/22 * ((*funp)(a) + (*funp)(b));  
24.     return z;  
25.  }  
26.   
27. double f1(double x){  
28.     return x*x;  
29. }  
30.   
31. double f2(double x){  
32.     return sin(x)/x;  
33. }  

42）链表

42.1）链表的建立：使用结构的嵌套来定义单向链表结点的数据类型

例子：

[objc] view plain copy

1. struct stud_node{  
2.   int num;  
3.   char name[20];  
4.   int score;  
5.   struct stu_node *next;  
6. };  

42.2）链表是一种动态存储分配的数据结构，在进行动态存储分配的操作，需要函数malloc()、free()

例子：

[objc] view plain copy

1. struct stud_node *p;  
2.     p = (struct stud_node *)malloc(sizeof(struct stud_node));  

若申请成功，p指向被分配内存空间的起始地址；若未申请到内存空间，则p的值为NULL

42.3）链表的遍历：ptr = ptr -> next

由于各结点在内存中不是连续存放的，所以不可以用ptr++来寻找下一个结点

42.4）插入结点：先连后断

例子：ptr1和ptr2原先是连在一起的，现在在中间插入一个ptr

[objc] view plain copy

1. ptr->next = ptr2;  
2.     ptr1->next = ptr;  

42.5）删除结点：先接后删

例子：ptr1和ptr2原先是连在一起的，现在删除ptr2

[objc] view plain copy

1. ptr1->next = ptr2->next;  
2.     free(ptr2);  

43）文件

43.1）文本文件，以字符ASCII码值进行存储与编码的文件

例如，整数1234，存放在文本文件中，是40、50、51、52，是'1' 、'2' 、‘3’、‘4’的ASCII码值，占4个字节

43.2）二进制文件，存储二进制数据的文件

例如，整数1234，存放在二进制文件中，是二进制数0x04D2，共两个字节

43.3）打开文件，格式fopen("文件名", "文件打开方式")，返回值是地址，没有则NULL

文件打开方式如下：

文件打开失败的原因有：文件不存在、路径不对、已经被打开、文件存储有问题

注意：

不写路径的话，默认与当前应用程序路径相同

以写的方式打开的话，文件可以不存在，存在的话，会被清空，重新开始写。不想重写的话，就追加的方式打开

exit(0)，关闭所有打开的文件，终止程序的运行。。。在 #include <stdlib>中

43.4）关闭文件，格式 fclose(文件指针)； //返回0表示正常关闭

43.5）文件读写

43.51）字符读取，ch = fgetc(fp); 从文件中，读取一个字符赋值给ch，其中fp是文件指针

43.52）字符写入, fputc(ch, fp)； 把ch写入到文件

43.53）字符串读取， fgets(s,n,fp); 从文件中读取最多n-1个字符，再加上'\0'，赋值给s。。若有换行符或文件结束标志EOF，即使不到n-1个，这个函数也结束了

43.54）字符串写入，fputs(s,fp)；把s写入文件中，结束符'\0'不写入文件

43.55）格式化读取，fscanf(文件指针， 格式字符串，输入表)

43.56）格式化写入，fprintf(文件指针，格式化字符串，输出表)

例子：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib>  
3.   
4. int main()  
5.  {  
6.     FILE *fp1, *fp2;  
7.     char ch;  
8.     //打开文件，读取数据  
9.     if((fp1 = fopen("f12-2.txt", "r")) == NULL){  
10.         printf("File open error!\n");  
11.         exit(0);  
12.     }  
13.   
14.     //打开文件，写入数据  
15.     if((fp2 = fopen("f12-3.txt", "w")) == NULL){  
16.         printf("File open error!\n");  
17.         exit(0);  
18.     }  
19.   
20.     //数据数据，从文件1读取，写入到文件2  
21.     while(!feof(fp1)){//判断是否到达文件末尾，平时返回0，遇到EOF返回1  
22.         ch = fgetc(fp1);  
23.         if(ch != EOF) fputc(ch, fp2);  
24.     }  
25.   
26.     //关闭文件  
27.     if(fclose(fp1)){ //正常关闭，返回0  
28.         printf("Can not close the file\n");  
29.         exit(0);  
30.     }  
31.   
32.     if(fclose(fp2)){ //正常关闭，返回0  
33.         printf("Can not close the file\n");  
34.         exit(0);  
35.     }  
36.     return 0;  
37.  }  

版权声明：举报

• 标签：
• C语言随笔

 

相关文章推荐

PE 头打印 c语言随笔

• 2016-02-14 12:49
• 5KB
• 下载

[Object-C语言随笔之一]Mac os 下搭建iOS开发环境

李华明Himi 原创,转载务必在明显处注明：转载自【黑米GameDev街区】 原文链接: http://www.himigame.com/iphone-object/391.html   从这一章开始...

• 
• xiaominghimi
• 2011-06-24 15:22
• 49651

零基础的学习心路：12个机器学习案例实战！

都说今年是AI开发元年，为了转型AI技术程序员，这小半年来看了几本书，总结了一些学习的方法和踩过的坑儿，今天我想谈谈关于机器学习该如何入门以及学习方法....

C语言随笔(1)

函数功能：复制串口调试助手中接收到的数据，保存为文件。 void SaveCOMtoFile(const char *fileName, const char *mode) { HWND pare...

• 
• Cration_523
• 2011-11-12 14:32
• 150

【随笔】C语言_基本概念

计算机中常见的进制:二进制、八进制、十进制、十六进制，八进制以0开头，十六进制以0x开头。 进制之间互相转换，以二进制为中介。 //  单行注释       /* * 多行注释 */ byte（...

• 
• LSQXSTC
• 2015-03-21 11:03
• 307

C语言随笔（strcat的实现）

今天看C语言教程的时候，看到有关指针，字符串数组

• 
• gwbbigbang
• 2014-04-13 22:23
• 474

C语言随笔之测试题（2）

1.下面代码中哪些内容可以被改写

• 
• gwbbigbang
• 2014-04-23 13:31
• 468

C语言随笔（指针）

1.学习习惯。 在编写C语言程序时候，不要简单的printf成功就

• 
• gwbbigbang
• 2014-04-09 19:48
• 434

C语言学习随笔（1）—— 学些什么？

C语言的学习主要从四个部分进行入手，分别是C语言的基本语法，设计、编程的思想，数据结构的学习以及大量的编程练习。 一、C语言的基本语法方面 编程语言他本质上也是一种语言，只不过没有我们平时的交流中使用...

• 
• a354244002
• 2016-08-26 15:28
• 131

C语言_指针随笔

指针： 指针就是地址，地址就是指针。地址就是内存单元的编号。指针变量是存放地址的变量（例：int* p，这里的p就是指针变量，用于存放地址）     指针和指针变量是两个不同的概念：平时也...

• 
• qq_24692041
• 2017-03-02 17:33
• 83

[Object-C语言随笔之二] 《NSLog》常用的打印调试语句与自动排版

李华明Himi 原创,转载务必在明显处注明：转载自【黑米GameDev街区】 原文链接: http://www.himigame.com/iphone-object/395.html     虽然C语...

• 
• xiaominghimi
• 2011-06-27 17:05
• 19393

[Object-C语言随笔之三] 类的创建和实例化以及函数的添加和调用！

李华明Himi 原创,转载务必在明显处注明：转载自【黑米GameDev街区】 原文链接: http://www.himigame.com/himistudy/396.html 上一小节的随笔写了常用的...

• 
• xiaominghimi
• 2011-06-30 15:56
• 14600

C语言随笔（宏 注释 词法）

准备C语言进阶，看了一些关于C语言d

• 
• gwbbigbang
• 2014-04-11 00:13
• 683

[Object-C语言随笔之四]创建视图并绘制简单图形

李华明Himi 原创,转载务必在明显处注明：转载自【黑米GameDev街区】 原文链接: http://www.himigame.com/iphone-object/401.html这段时间N忙，没办...

• 
• xiaominghimi
• 2011-07-25 21:57
• 14509

C语言学习随笔（3）—— 学习内容简述

在对学习的方向以及目标有了一定了解后，开始对C语言的内容进行简单的了解，方便后续学习中的各项工作的展开。同时，这也是对今后学习进度的一个类似索引的东西。东西比较多，这里就不一一列举了，直接开始说明。 ...

• 
• a354244002
• 2016-08-29 09:07
• 87

C语言学习随笔

1.C程序链接如何生成指定的文件名。 使用 cc  –c目标文件名 –o 文件名 cc 源程序名 –o 文件名   2.文件名命名中间不能有空格，不然终端会识别为两个文件。   3.cc –c指令可以...

• 
• u011955603
• 2014-07-18 18:07
• 376

※C++随笔※=>☆C++基础☆=>※№ C语言与C++语言之间关系

很多时候我们对于C和C++的区别不是很清楚，以至于弄混的情况并不少见。那C语言和C++语言到底是怎么回事呢？         首先，我们来看下百度百科对语言和C++语言描述，相对而说也还算是...

• 
• xiaoting451292510
• 2013-03-01 18:24
• 24861

C语言中基本的输入和输出函数的用法第一讲（C语言学习随笔三）

C语言中基本的输入和输出函数的用法第一讲 输出函数printf()（输出到显示器）的用法：a、printf（"字符串"）； b、printf（“输出控制符列表”，输出参数列表）； 常用输出控制符...

• 
• tianshijianbing1989
• 2011-09-15 13:09
• 683

C 语言随笔

昨天写的文章，格式明显不好。今天希望有个进步。

• 
• gwbbigbang
• 2014-04-08 20:49
• 422

随笔----go语言版快速排序

快速排序对于一个合格的程序员来说do

• 
• KeKeQiaoKeLi
• 2014-10-10 21:05
• 612

R语言学习 随笔 01

R语言是机器学习的一大利器，很多有秀代码都这他来写的，为了学习之，还是要学的。R的Rstudio也是很好用的IDE，原来用的MATLAB后来学了Python，现在学R感觉这布局更让人亲切。 本文是初...

• 
• bea_tree
• 2016-04-17 13:59
• 432

编程语言题目随笔

1. 在用#define 定义时 , 斜杠("\")是用来续行的，"#"用来把参数转换成字符串，是给参数加上双引号。"##"则用来连接前后两个参数，把它们变成一个字符串,"#@"是给参数加上单引号。 ...

• 
• yuxue_23
• 2013-09-27 10:29
• 632

脚本语言对比学习随笔

程序语言学习 一起对照学习，通过发现差异，引发思考，更有心得，理解更扎实 操作大于纯理论，使用vim，快速频繁的练习 评价语言不是开发快，而是简洁直观，因为维护重构和演进更重要 语言分类学习数据类型，...

• 
• kaven2762
• 2016-08-06 22:09
• 318

读【36岁IT老人再次随笔】的读后感，你会哪些计算机语言？

论坛首页一篇：社区“揭穿最大谎言”事件 ， 我看了，也顺便看了里面另一位仁兄的【36岁IT老人再次随笔】 其中关键的地方就是一个例子：你会哪些计算机语言？ 这个问题很有意思，确实如网友回复...

• 
• szu030606
• 2012-02-11 12:44
• 1104

9.19随笔 UML建模语言.

今天是陈老师带领我们做实训项目的第一天。 交给我们用Rose软件画UML图。 有了一定的基础掌握。就像陈老师说的一样，要想做好项目，图一定要架构好。通过了对作业的独立完成，已经对Rose软件有了一定...

• 
• qiwancong
• 2011-09-19 20:44
• 277

C语言编程练习随笔

/*#include int main() { int i, j, k, l, n, m=0; int a[120]; for (i = 1; i for (j = 1; j for (k = 1...

• 
• lzl_Avery
• 2016-12-30 21:31
• 234

随笔：弱类型语言javascript中的一些小坑

测试1: (未声明变量自动提升为全局变量) test1(); function test1() { function setName() { name = '张三'; // 此...

• 
• Tyro_java
• 2016-03-23 00:08
• 803

C 语言随笔之测试题

1.下面代码的输出

• 
• gwbbigbang
• 2014-04-21 01:15
• 590

C语言printf("")，浮点数打印保留有效位数，小数部分的四舍五入

1.printf("%3.0f",floatNum)：不保留小数 说明：%3.0f表明待打印的浮点数（floatNum）至少占3个字符宽，且不带小数点和小数部分，整数部分至少占3个位宽； 注意：这里的...

• 
• abcdu1
• 2017-07-13 19:16
• 740

C语言关键字const

关键字const用来定义常量，如果一个变量被const修饰，那么它的值就不能再被改变，我想一定有人有这样的疑问，C语言中不是有#define吗，干嘛还要用const呢，我想事物的存在一定有它自己的道理...

• 
• u011559046
• 2017-06-25 16:13
• 63

C语言第七次作业练习

以下程序教材基于 谭浩强C程序设计（第四版）第1题 完成例6.9，有3个字符串，要求找出其中最大者。# include # include int main(void) { ch...

• 
• Judikator
• 2017-04-29 23:50
• 61

一个按时提醒休息的简单C语言程序

我经常沉迷学习，无法自拔（误）(～￣▽￣)～，以至于忘了时间。 由于长时间使用电脑，会损害视力，效率也会降低，所以我想做一个能够按时提醒我休息的程序。 当然每一次提醒都不用专门设定时间，那样就太麻烦而...

• 
• SIENTIST
• 2017-04-18 19:47
• 129

C语言编译步骤

C语言从代码变成可执行程序的步骤： 预处理 -----> 编译 -----> 汇编 -----> 链接 ⒈预处理：去掉注释，加载头文件，代替宏定义，条件编译 需要文件：.c文件 ...

• 
• egbert123
• 2017-03-25 11:15
• 58

C语言内存分配

C语言内存分配C语言的内存分配有静态内存以及动态动态,静态内存由系统分配并释放,动态内存由自己申请与释放.静态内存静态内存是由栈空间分配的,由系统自动分配,自动释放(随机释放)main() { ...

• 
• itheimach
• 2016-11-30 23:28
• 127

C语言堆和栈的区别

在计算机领域，堆栈是一个不容忽视的概念，我们编写的C语言程序基本上都要用到。 但对于很多的初学着来说，堆栈是一个很模糊的概念。堆栈：一种数据结构、一个在程序运 行时用于存放的地方，这可能是...

• 
• u012853614
• 2016-04-14 12:16
• 88

C语言职工管理系统设计

代码如下:#include #include #include struct Worker { int id;//工号 char name[16];//姓名 char sex...

• 
• qq_18297675
• 2016-04-13 11:30
• 248

hdu2104 hide handkerchief（C语言）

Problem Description The Children’s Day has passed for some days .Has you remembered something happe...

• 
• sinat_39591298
• 2017-07-31 22:42
• 46

C语言-基本数据类型

各种数据类型介绍（1）整型1.1 短整型 short a = 11.2 整型 　一般占4个字节（32位），最高位代表符号，0表示正数，1表示负数，取值范围是-2147483648~2147...

• 
• WiKi_Su
• 2017-07-26 15:20
• 74

C语言实现串的基本模式匹配

前言本程序是数据结构上机实验内容，参考《数据结构（C语言版）》（清华大学出版社）中串操作部分的伪代码实现。题目要求设计一个程序实现串的基本模式匹配。所谓模式匹配，就是判断某个串是否是另一个已知串的子串...

• 
• lgj123xj
• 2017-05-24 14:45
• 219

C语言和Lua交互(四)

C语言创建lua table变量

• 
• uisoul
• 2017-03-10 15:04
• 55

c语言练习题——基础4

《c语言练习题——基础4》   1.编写函数void count(char a[],char w[][10],int n,int b[])。功能是：统计w指向的数组中的n个单词在a指向的字符串中各自出...

• 
• Ivan804638781
• 2016-08-31 19:57
• 186

C语言内存布局

一.C程序的基本组成及产生过程 一个程序本质上都是由 BSS 段、data段、text段三个组成的。 C程序编译的完整过程：C源代码---->预编译处理（.c）---->编译、优化程序（.s、.a...

• 
• LYX_WIN
• 2016-08-18 22:37
• 131

水滴石穿C语言之typedef的问题

1. 基本解释 　　typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。 　　在编程中使用...

• 
• sinat_29741049
• 2015-11-14 18:24
• 220

黑马程序员———C语言———【二维数组、字符串】

————————————————————————————————————————————————————————————————————————————— 一、二维数组的定义 1、概念：可以看做是一个...

• 
• qq_30470559
• 2015-08-12 14:37
• 706

队列（C语言）

#include #include typedef int elemType; typedef struct List { elemType elem; struct List* next; ...

• 
• u011385799
• 2015-08-06 10:21
• 282

详解C语言external-internal-none链接属性

链接属性 external(外部)　这种链接属性的标识符无论声明多少次，位于几个源文件都表示一个实体。例如下面的代码： 文件名为main.c #include int stud...

• 
• xlinsist
• 2015-06-25 08:58
• 889

SVM入坑随笔

• 2017-02-26 03:45
• 3.96MB
• 下载

Lotus_Notes程序设计随笔(精典)

• 2015-10-17 21:29
• 69KB
• 下载

SIEMENS200/300随笔

• 2015-05-09 18:13
• 1.72MB
• 下载

Ext相关随笔

• 2013-08-19 21:16
• 206KB
• 下载

python随笔

• 2014-04-29 04:43
• 4KB
• 下载

随笔小记文档及若干代码

• 2014-07-16 21:33
• 21.49MB
• 下载

android 随笔40K

• 2014-10-12 10:21
• 561KB
• 下载

林信良先生的随笔整理

• 2009-03-08 23:09
• 60KB
• 下载

人月神话--软件工程管理随笔

• 2012-07-04 14:23
• 2.54MB
• 下载

MINA2.0用户手册中文随笔翻译

• 2014-11-01 20:54
• 1.99MB
• 下载

TCPIP协议随笔

• 2015-05-27 11:40
• 297KB
• 下载

嵌入式随笔联系

• 2014-08-25 20:58
• 862B
• 下载

awt开发工具学习随笔

• 2015-05-19 09:02
• 74KB
• 下载

javaweb随笔

• 2012-03-11 21:14
• 666KB
• 下载

网页设计随笔

• 2012-10-28 17:42
• 2.41MB
• 下载

品味蓝色II__IBM人价值随笔

• 2012-02-15 13:36
• 14.22MB
• 下载

Dagger 工作随笔

• 2015-04-10 15:40
• 563KB
• 下载

李建壹 Louis Lee(小路哥 lotus Notes开发随笔.

• 2009-07-28 11:43
• 37KB
• 下载

电子工程师设计经验随笔

• 2010-04-09 16:45
• 167KB
• 下载

解决Eclipse3.6（Helios）随笔提示相应过慢问题

• 2012-12-09 19:59
• 4.29MB
• 下载

Ibatis学习随笔

• 2008-07-20 22:45
• 37KB
• 下载

网络管理随笔

• 2013-01-14 15:13
• 2.17MB
• 下载

学习php随笔

• 2014-07-22 15:07
• 6.05MB
• 下载

博客按键消抖试验及验证随笔及之前的源码

• 2017-07-24 11:28
• 63.54MB
• 下载

java课堂随笔

• 2015-06-05 00:40
• 6KB
• 下载

ARM-linux(fedora)随笔

• 2012-04-28 14:42
• 866KB
• 下载

Java完整随笔（学习）

• 2014-10-16 17:23
• 5.34MB
• 下载

林信良先生的随笔.doc

• 2008-07-07 21:48
• 60KB
• 下载

林信良先生的随笔.doc

• 2008-05-24 08:00
• 60KB
• 下载

ACE学习随笔

• 2008-01-15 18:40
• 42KB
• 下载

设计模式随笔系列

• 2008-07-16 15:57
• 932KB
• 下载

计算机汉字录入课程项目训练考核教学随笔.pdf

• 2009-11-17 12:36
• 1.34MB
• 下载

oracle 数据仓库随笔

• 2011-06-29 15:58
• 547KB
• 下载

oracle随笔

• 2013-08-21 12:43
• 245KB
• 下载

js随笔提示

• 2012-10-12 10:33
• 32KB
• 下载

rtklib随笔

• 2015-08-31 10:48
• 12KB
• 下载

欧阳坚视频教程随笔，对于初学者有河大的帮助。

• 2014-05-09 17:14
• 75KB
• 下载

c语言标准参考手册

• 2017-09-18 09:02
• 380KB
• 下载

C语言C11标准

• 3天前 15:06
• 1.61MB
• 下载

GBK转UTF C语言 单片机

• 4天前 15:24
• 47KB
• 下载

javolution-5.5.1.jar(最新版本java解析c语言结构体的jar包)

• 5天前 11:28
• 386KB
• 下载

高质量程序设计指南C＋＋_C语言（第三版）

• 6天前 16:06
• 36.88MB
• 下载

C语言各知识点详细总结

• 2017-09-23 18:43
• 530KB
• 下载

linux c语言实现websocket