C语言程序内存分配

(1) & 与 * 操作

取地址运算符 &: p = &c;

--表达式解析: 将 c 的地址赋值给 变量 p, p 是指向 c 变量的指针;

--& 可以使用的情况: 取地址操作 只能用于内存中的对象, 如变量 或 数组, 栈内存 堆内存 都可以;

--& 不适用的情况: 不能用于 表达式, 常量, register类型变量;

间接引用运算符: * ;

--声明指针: int *p ; 该表达式的含义是*p 的结果是 int 类型, 声明变量 a, int a, 声明指针 *p , int *p;

--获取指针指向的值: int a = *p ;

(2) 指针定义解析

声明指针 和 函数: int *p, max(int a, int b), 声明指针变量 语法 与声明 变量语法类似, 同理声明函数也一样;

--原理: *p 和 max()返回值 类型都是 int 类型;

指针指向: 每个指针都必须指向某种特定类型;

--例外: void *p 可以指向任何类型, 但是 p 不能进行取值运算, *p 是错误的, 因为不知道 p 指向的数据类型;

(3) 指针运算及示例

指针相关运算: int x = 0; int *p = &x; 那么*p 就可以代表x;

--算数运算: x = x + 1; 等价于 *p = *p + 1 ; int y = x + 1; 等价于 int y = *p + 1;

--自增运算: 前提 : ++, * 运算顺序是自右向左; ++*p 和 (*p)++, p 指向的值自增1, 注意要加上括号, 否则会将地址自增;

--指针赋值: int *p, *q; int a = 0; p = &a; q = p; 最终结果 p 和 q 都指向了 变量 a;

示例程序:

[cpp]view plaincopy

1. /*************************************************************************
2. >FileName:pointer_address.c
3. >Author:octopus
4. >Mail:octopus_work.163.com
5. >CreatedTime:Mon10Mar201409:52:01PMCST
6. ************************************************************************/
8. #include
10. intmain(intargc,char**argv)
11. {
12. int*p,*q;
13. inta=10,b;
15. //p指针指向a变量
16. p=&a;
18. //*p可以代替a进行运算
19. ++*p;
21. b=*p+5;
23. //指针之间可以直接相互赋值
24. q=p;
26. //打印p和q指针指向的值
27. printf("*p=%d",*p);
28. printf("*q=%d",*q);
31. return0;
32. }

执行结果:

[cpp]view plaincopy

1. [root@ip28pointer]#gccpointer_address.c
2. [root@ip28pointer]#./a.out
3. *p=11
4. *q=11

4. 函数参数的传值调用和传址调用

(1) 传值调用 和 传址调用

传值调用: 以传值的方式将参数传递给函数, 不能直接修改主函数中变量的值, 仅仅是将副本传递给了函数;

传址调用: 将 变量的指针 传递给函数, 当函数对指针进行操作的时候, 主函数中的值也进行了对应变化;

交换函数示例1:

[cpp]view plaincopy

1. /*************************************************************************
2. >FileName:swap.c
3. >Author:octopus
4. >Mail:octopus_work.163.com
5. >CreatedTime:Mon10Mar201411:07:18PMCST
6. ************************************************************************/
8. #include
10. voidswap_1(inta,intb)
11. {
12. inttemp;
13. temp=a;
14. a=b;
15. b=temp;
17. printf("swap_1传值函数a=%d,b=%d",a,b);
18. }
20. voidswap_2(int*a,int*b)
21. {
22. inttemp;
23. temp=*a;
24. *a=*b;
25. *b=temp;
27. printf("swap_2传址函数a=%d,b=%d",*a,*b);
28. }
30. intmain(intargc,char**argv)
31. {
32. inta=10,b=5;
34. printf("初始值:a=%d,b=%d",a,b);
36. swap_1(a,b);
37. printf("执行swap_1函数,a=%d,b=%d",a,b);
39. swap_2(&a,&b);
40. printf("执行swap_2函数,a=%d,b=%d",a,b);
43. return0;
44. }

执行结果:

[cpp]view plaincopy

1. [root@ip28pointer]#gccswap.c
2. [root@ip28pointer]#./a.out
3. 初始值:a=10,b=5
5. swap_1传值函数a=5,b=10
6. 执行swap_1函数,a=10,b=5
8. swap_2传址函数a=5,b=10
9. 执行swap_2函数,a=5,b=10

示例解析:

--传值调用: swap_1 是传值调用, 传入的是 main 函数中的 a b 两个变量的副本, 因此函数执行完毕后, 主函数中的值是不变的;

--传址调用: swap_2 是传址调用, 传入的是 a , b 两个变量的地址 &a, &b, 当在swap_2 中进行修改的时候, 主函数中的 a,b变量也会发生改变;

(2) 高级示例

需求分析: 调用getint()函数, 将输入的数字字符 转为一个整形数据;

getch 和 ungetch 函数:

--使用场景: 当进行输入的时候, 不能确定是否已经输入足够的字符, 需要读取下一个字符, 进行判断, 如果多读取了一个字符, 就需要将这个字符退回去;

--使用效果: getch() 和 ungetch() 分别是预读下一个字符, 和 将预读的字符退回去, 这样对于其它代码而言, 没有任何影响;

注意的问题 : 出现问题, 暂时编译不通过, 找个C语言大神解决;

代码:

[cpp]view plaincopy

1. /*************************************************************************
2. >FileName:getint.c
3. >Author:octopus
4. >Mail:octopus_work.163.com
5. >CreatedTime:Mon10Mar201411:40:19PMCST
6. ************************************************************************/
7. #include
8. #include
9. #include
10. #defineSIZE5
12. intgetint(int*p)
13. {
14. //sign是用来控制数字的正负
15. intc,sign;
17. //跳过空白字符,如果是空白字符,就会进行下一次循环,直到不是空白字符为止
19. while(isspace(c=getc(stdin)));
21. //如果输入的字符不是数字,就将预读的数据退回到标准输入流中
22. if(!isdigit(c)&&c!=EOF&&c!=+&&c!=-)
23. {
24. ungetc(c,stdin);
25. return0;
26. }
28. /*
29. *如果预读的是减号,那么sign标识就是-1,
30. *如果预读的是加号,那么sign标识就是1;
31. */
32. sign=(c==-)?-1:1;
33. //如果c是加号或者减号,再预读一个字符&
34. if(c==+||c==-)
35. c=getc(stdin);
37. for(*p=0;isdigit(c);c=getc(stdin))
38. *p=10**p+(c-0);
40. *p*=sign;
42. if(c!=EOF)
43. ungetc(c,stdin);
45. returnc;
47. }
49. intmain(intargc,char**argv)
50. {
51. intn,array[SIZE],i;
52. for(n=0;n
54. for(i=0;i
55. {
56. printf("array[%d]=%d",i,array[i]);
57. }
58. return0;
59. }

执行结果:

[plain]view plaincopy

1. octopus@octopus-Vostro-270s:~/code/c/pointer$./a.out
2. 123
3. 12343
4. 6741
5. array[0]=123
6. array[1]=123
7. array[2]=43
8. array[3]=674
9. array[4]=1

5. 指针 和 数组

指针数组比较:

--可互相替代: 数组下标执行的操作都可以使用指针替代;

--效率比较: 使用指针操作效率比数组要高;

指针 与 数组初始化:

--声明数组: int a[10]; 定义一个长度为10 的int数组;

--声明指针: int *p; 定义一个指针, 该指针指向整型;

--相互赋值: p = &a[0], 将数组第一个元素的地址赋值给指针变量;

--使用指针获取数组对象: *p 等价于 a[0], *(p + 1) 等价于 a[1], *(p + i)等价于 a[i];

--注意地址的运算: p + i , 在地址运算上, 每次增加 sizeof(int) * i 个字节;

将数组赋值给指针的途径:

--将数组第一个元素地址赋值给指针变量: p = &a[0];

--将数组地址赋值给指针变量: p = a;

指针 和 数组 访问方式互换: 前提 int *p, a[10]; p = a;

--数组计算方式: 计算a[i]的时候, 先将数组转化为 *(a + i)指针, 然后计算该指针值;

--取值等价: a[i] 等价于 *(p + i);

--地址等价: &a[i] 与 a + i 是等价的;

--指针下标访问: p[i] 等价于 *(p + i);

--结论: 通过数组和下标实现的操作 都可以使用指针和偏移量进行等价替换;

指针 和 数组 的不同点:

--指针是变量: int *p, a[10]; p = a 和 p++ 没有错误;

--数组名不是变量: int *p, a[10]; a = p 和 a++ 会报错;

数组参数:

--形参指针: 将数组传作为参数传递给函数的时候, 传递的是数组的首地址, 传递地址, 形参是指针;

数组参数示例:

--函数参数是数组: 函数传入一个字符串数组参数, 返回这个字符串长度;

[cpp]view plaincopy

1. /*************************************************************************
2. >FileName:array_param.c
3. >Author:octopus
4. >Mail:octopus_work.163.com
5. >CreatedTime:Sat15Mar201412:46:57AMCST
6. ************************************************************************/
8. #include
10. //计算字符串长度
11. intstrlen(char*s)
12. {
13. intn;
14. for(n=0;*s!=;s++)
15. n++;
16. returnn;
17. }
19. intmain(intargc,char**argv)
20. {
21. printf("strlen(djdhaj)=%d",strlen("djdhaj"));
22. printf("strlen(12)=%d",strlen("12"));
23. printf("strlen(dfe)=%d",strlen("dfe"));
24. }

--执行结果:warning: conflicting types for built-in function ‘strlen’, 原因是 C语言中已经有了 strlen 函数了, 如果改一个函数名, 就不会有这个警告了;

[plain]view plaincopy

1. [root@ip28pointer]#gccarray_param.c
2. array_param.c:12:warning:conflictingtypesforbuilt-infunction‘strlen’
3. [root@ip28pointer]#./a.out
4. strlen(djdhaj)=6
5. strlen(12)=2
6. strlen(dfe)=3

数组和指针参数:将数组名传给参数, 函数根据情况判断是作为数组还是作为指针;

--实参: 指针偏移量 和 数组下标 都可以作为 数组或指针函数形参, 如 数组情况fun(&array[2]) 或者 指针情况fun(p + 2);

--形参: 函数的形参可以声明为 fun(int array[]), 或者 fun(int *array), 如果传入的是数组的第二个元素的地址, 可以使用array[-2]来获数组取第一个元素;

数组指针参数示例:

[cpp]view plaincopy

1. /*************************************************************************
2. >FileName:param_array_pointer.c
3. >Author:octopus
4. >Mail:octopus_work.163.com
5. >CreatedTime:Sat15Mar201401:28:33AMCST
6. ************************************************************************/
8. #include
10. //使用指针做形参取指针的前两位和当前位
11. voidfun_p(int*p)
12. {
13. printf("*(p-2)=%d",*(p-2));
14. printf("*p=%d",*p);
15. }
17. //使用数组做形参取数组的第-2个元素和第0个元素
18. voidfun_a(intp[])
19. {
20. printf("p[-2]=%d",p[-2]);
21. printf("p[0]=%d",p[0]);
22. }
24. intmain(intargc,char**argv)
25. {
26. intarray[]={1,2,3,4,5};
27. //向指针参数函数中传入指针
28. printf("fun_p(array+2):");
29. fun_p(array+2);
31. //向数组参数函数中传入数组元素地址
32. printf("fun_a(&array[2]):");
33. fun_a(&array[2]);
35. //向指针参数函数中传入数组元素地址
36. printf("fun_p(&array[2]):");
37. fun_p(&array[2]);
39. //向数组参数函数中传入指针
40. printf("fun_a(array+2):");
41. fun_a(array+2);
42. return0;
43. }

执行效果:

[plain]view plaincopy

1. [root@ip28pointer]#gccparam_array_pointer.c
2. [root@ip28pointer]#./a.out
3. fun_p(array+2):
4. *(p-2)=1
5. *p=3
6. fun_a(&array[2]):
7. p[-2]=1
8. p[0]=3
9. fun_p(&array[2]):
10. *(p-2)=1
11. *p=3
12. fun_a(array+2):
13. p[-2]=1
14. p[0]=3

http://blog.csdn.net/shulianghan/article/details/20472269