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 135typedef 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 135typedef int TYPE;int main(){ const TYPE ca; ca=4;//编译出错位置 return 0;}

 

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

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

//编译 gcc const.c//运行 ./a.out#include<stdio.h>#define VALUE 135typedef 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 pconst TYPE *p          等价 TYPE const*pconst 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  235typedef 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  235typedef 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  235typedef 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  235typedef 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  235typedef 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  235typedef 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  235typedef 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  235typedef 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  235typedef 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  235typedef 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  235typedef 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;}