Linux下C测试const

根据链接 http://www.cnblogs.com/madonion/articles/2266163.html 里面的关于纯C的描述（不涉及C++的部分）测试结果。

编译器gcc

正确、警告、出错。

正确和警告均可执行，其中警告具有破坏性，

比如明明定义了const TYPE ca=1;但是指定TYPE*p=&ca;或者TYPE*const p=&ca;后序通过*p=3;结果ca的值被改变了！！

错误即编译的时候出错，无法执行。

*********************

只读变量

*********************

无意义

#include<stdio.h> #define VALUE 135 typedef int TYPE; int main() { const TYPE ca;//无意义，只读，没有初始化定义，gcc默认为0 return 0; }

***********************

出错

const_.c: In function ‘main’: const_.c:9: 错误：向只读变量 ‘ca’ 赋值

//编译 gcc const.c #include<stdio.h> #define VALUE 135 typedef int TYPE; int main() { const TYPE ca; ca=4;//编译出错位置 return 0; }

 

***********************

正确使用（只读，即：定义并初始化，后续值不可更改）

//编译 gcc const.c //运行 ./a.out #include<stdio.h> #define VALUE 135 typedef int TYPE; extern const TYPE ca;//声明：大型程序中连接其他文件，其他文件或本文件中有初始值。 const TYPE ca=VALUE;//定义+初始化 int main() { const TYPE ca=4;//命名冲突，取范围内的这个ca printf("%d\n",ca); return 0; }

***********************

指针和const的排列组合四种方式(此项extern的不做介绍)

***********************

TYPE *p TYPE *const p const TYPE *p 等价 TYPE const*p const TYPE *const p 等价 TYPE const*const p

指针一个是改变指向地址里面的内容，一个是改变指向地址

***********************c(0,0)可在后续进行变量赋值，而位置赋值两种情况，指向的是const TYPE*而进行位置赋值会警告（破坏性），指向的TYPE*进行位置赋值程序正确

正确

//编译 gcc const.c //运行 ./a.out #include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; TYPE a1=VALUE; TYPE*p; p=&a; printf("memory:%p\ndata:%d\n",p,*p); *p=VALUE2; printf("memory:%p\ndata:%d\n",p,*p); p=&a1; printf("memory:%p\ndata:%d\n",p,*p); return 0; }

memory:0x7fffa431b494 data:135 memory:0x7fffa431b494 data:235 memory:0x7fffa431b490 data:135

--------------

警告

const_.c: In function ‘main’: const_.c:11: 警告：赋值丢弃了指针目标类型的限定

#include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { const TYPE ca=VALUE; TYPE*p; p=&ca;//警告 return 0; }

***********************c(0,1)后续变量赋值出错，而关于位置赋值两种情况，指向的是const TYPE*而进行位置赋值会警告（破坏性），指向的TYPE*进行位置赋值程序正确

正确

//编译 gcc const.c //运行 ./a.out #include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; TYPE *const p=&a; printf("TYPE *const p=a;\n"); printf("memory:%p data:%d\n",p,*p); *p=VALUE2; printf("*p=VALUE2\n"); printf("memory:%p data:%d\n",p,*p); return 0; }

--------

警告

const_.c: In function ‘main’: const_.c:12: 警告：初始化丢弃了指针目标类型的限定

//编译 gcc const.c //运行 ./a.out #include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; TYPE *const p=&a; const TYPE ca=VALUE; TYPE *const pp=&ca;//警告 printf("TYPE *const p=a;\n"); printf("memory:%p data:%d\n",p,*p); *p=VALUE2; printf("*p=VALUE2\n"); printf("memory:%p data:%d\n",p,*p); printf("\n"); printf("TYPE *const p=ca;\n"); printf("memory:%p data:%d\n",pp,*pp); *pp=VALUE2;//警告的原因 printf("*pp=VALUE2\n"); printf("memory:%p data:%d\n",pp,*pp); printf("const TYPE ca 's value %d\n",ca); return 0; }

打印结果：

TYPE *const p=a; memory:0x7fffff89092c data:135 *p=VALUE2 memory:0x7fffff89092c data:235

TYPE *const p=ca; memory:0x7fffff890928 data:135 *pp=VALUE2 memory:0x7fffff890928 data:235 const TYPE ca 's value 235

-------- 出错

const_.c: In function ‘main’: const_.c:12: 错误：向只读变量 ‘p’ 赋值 const_.c:13: 错误：向只读变量 ‘p’ 赋值

#include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; const TYPE ca=VALUE; TYPE *const p; p=&a; p=&ca; return 0; }

------

出错

const_.c: In function ‘main’: const_.c:12: 错误：向只读变量 ‘p’ 赋值

#include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; TYPE a1=VALUE; TYPE *const p=&a; p=&a1; return 0; }

***********************c(1,0) 可在后续进行变量赋值，位置赋值出错

正确

//编译 gcc const.c //运行 ./a.out #include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; const TYPE ca=VALUE; TYPE const *p; p=&a; printf("memory:%p data:%d\n",p,*p); p=&ca; printf("memory:%p data:%d\n",p,*p); return 0; }

打印结果：

memory:0x7fff6f8175d4 data:135 memory:0x7fff6f8175d0 data:135

---------------

出错

const_.c: In function ‘main’: const_.c:15: 错误：向只读位置赋值 const_.c:19: 错误：向只读位置赋值

//编译 gcc const.c //运行 ./a.out #include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; const TYPE ca=VALUE; TYPE const *p; p=&a; printf("memory:%p data:%d\n",p,*p); *p=VALUE2;//出错 p=&ca; printf("memory:%p data:%d\n",p,*p); printf("memory:%p data:%d\n",p,*p); *p=VALUE2;//出错 printf("memory:%p data:%d\n",p,*p); return 0; }

***********************c(1,1)--必须定义的时候就确定，后续 变量赋值和位置赋值均出错

正确

//编译 gcc const.c //运行 ./a.out #include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; const TYPE ca=VALUE; TYPE const *const p=&a; TYPE const *const pp=&ca; printf("memory:%p data:%d\n",p,*p); printf("memory:%p data:%d\n",pp,*pp); return 0; }

 

出错

const_.c: In function ‘main’: const_.c:13: 错误：向只读变量 ‘p’ 赋值 const_.c:15: 错误：向只读位置赋值 const_.c:16: 错误：向只读变量 ‘p’ 赋值 const_.c:19: 错误：向只读位置赋值

//编译 gcc const.c //运行 ./a.out #include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; const TYPE ca=VALUE; TYPE const *const p; p=&a;//出错 printf("memory:%p data:%d\n",p,*p); *p=VALUE2;//出错 p=&ca;//出错 printf("memory:%p data:%d\n",p,*p); printf("memory:%p data:%d\n",p,*p); *p=VALUE2;//出错 printf("memory:%p data:%d\n",p,*p); return 0; }

出错

const_.c: In function ‘main’: const_.c:17: 错误：向只读变量 ‘p’ 赋值 const_.c:20: 错误：向只读变量 ‘pp’ 赋值

#include<stdio.h> #define VALUE 135 #define VALUE2 235 typedef int TYPE; int main() { TYPE a=VALUE; const TYPE ca=VALUE; TYPE a1=VALUE2; const TYPE ca1=VALUE2; TYPE const *const p=&a; TYPE const *const pp=&ca; printf("memory:%p data:%d\n",p,*p); p=&ca1;//出错 printf("memory:%p data:%d\n",p,*p); printf("memory:%p data:%d\n",pp,*pp); pp=&a1;//出错 printf("memory:%p data:%d\n",pp,*pp); return 0; }