const pStr p2 = “string”;

px
= &y; //正确,允许改换指向

  答案与剖析:

 #define PI 3.14159 //常量宏   
double I=PI; //编译期间进行宏替换,分配内存          
double J=PI; //再进行宏替换,又一次分配内存!
const double Pi=3.14159; //此时并未将Pi放入RAM中
double i=Pi; //此时为Pi分配内存,以后不再分配!      
double j=Pi; //没有内存分配

 

p2是const,是前二个const修饰的,*p1也被前三个const修饰,而p1被后一个const修饰。

  const int nValue; //nValue是const

6)

p2++;

如(1)中,如若想修改马克斯的剧情,只必要:const int 马克斯=you want;就能够! 

  char* const pContent;// pContent是const,*pContent可变

  1. 类中的常量:偶尔大家盼望有个别常量只在类中有效。由于#define定义的宏常量是全局的,不能够落得目标,于是想当然地感觉应该用const修饰数据成员来达成。const数据成员的确是存在的,但其含义却不是大家所期待的。const数据成员只在有个别对象生存期内是常量,而对此一切类来讲却是可变的,因为类能够创建七个目的,不相同的对象其const数据成员的值能够不一样。
    不可能在类申明中初步化const数据成员。以下用法是谬误的,因为类的对象未被成立时,编写翻译器不知道SIZE的值是怎么。

解析:p2++ 会报错。

double I=PI; //编译期间实行宏替换,分配内部存款和储蓄器 

中央解释

如何才具建设构造在整整类中都定位的常量呢?别期待const数据成员了,应该用类中的枚举常量来落到实处。比方
“`
class A
{…
enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量
int array1[SIZE1];
int array2[SIZE2];
};

const只修饰其后的变量,至于const放在类型前还是连串后并从未分别。如:const
int a和int const
a都是修饰a为const。注意*不是一连串型,假诺*pType在此之前是某项目,那么pType是指向该类型的指针。

int y =
2;

  难点:const变量 & const 限定的从头到尾的经过

typedef char* pStr;

const定义常量从汇编的角度来看,只是给出了相应的内部存储器地址,实际不是象#define同样付出的是即时数,所以,const定义的常量在程序运转进程中唯有一份拷贝,而#define定义的常量在内存中有好七个拷贝。 

  难题:const变量 & 字符串常量2

  1. const常用用法:左定值,右定向
    1)const在前面

const char *p1 = “string”;

const double Pi=3.14159; //此时从未有过将Pi放入RAM中 …… 

  const是一个C语言的关键字,它界定多少个变量不一样意被改换。使用const在料定水平上得以抓实程序的健壮性,其他,在收看外人代码的时候,清晰知道const所起的效用,对精晓对方的主次也可以有一对支援。

int x = 1;
int y = 2;
const int* px = &x;
int const* px = &x; //这两句表达式一样效果
px = &y; //正确,允许改变指向
*px = 3; //错误,不允许改变指针指向的变量的值

const使用的主导情势: const type
m;限定m不可变。替换基本形式中的m为1式中的*p1,替换后const char
*p1;限定*p1不可变,当然p1是可变的,因而难点中p1++是对的。替换基本方式中的type为2式中的pStr,替换后const
pStr
m;限定m不可变,题中的pStr便是一种新品类,由此难题中p2不可变,p2++是一无可取的。

const使用的骨干情势: const type
m;限定m不可变。替换基本格局中的m为1式中的*p1,替换后const char
*p1;限定*p1不可变,当然p1是可变的,由此难点中p1++是对的。替换基本方式中的type为2式中的pStr,替换后const
pStr
m;限定m不可变,题中的pStr正是一种新类型,由此难点中p2不可[1]变,p2++是不对的。

  1)、那个主题素材探究的是“常量”与“只读变量”的界别。常量料定是只读的,比如5,
“abc”,等,显著是只读的,因为程序中根本未曾地方贮存它的值,当然也就无法去修改它。而“只读变量”则是在内部存款和储蓄器中开辟贰个地点来存放它的值,只可是那几个值由编写翻译器限定不容许被改动。C语言关键字const正是用来限制四个变量分裂意被改成的修饰符(Qualifier)。上述代码中变量n被修饰为
只读变量,可惜再怎么修饰也不是常量。而ANSI
C规定数组定义时维度必须是“常量”,“只读变量”也是不可能的。

const Screen blankScreen;  
blankScreen.display();   // 对象的读操作  
blankScreen.set(‘*’);    // 错误:const类对象不允许修改  

p1++;

(6)提升了频率。 

  int const nValue; // nValue是const

答案:const使用的着力情势: const type
m;限定m不可变。替换基本格局中的m为1式中的*p1,替换后const char
*p1;限定*p1不可变,当然p1是可变的,因而难题中p1++是对的。替换基本情势中的type为2式中的pStr,替换后const
pStr m;限定m不可变,题中的pStr便是一种新品类,由此难题中p2不可
变,p2++是张冠李戴的。
7)在c中,对于const定义的指针,不赋初值编写翻译不报错,
int* const
px;这种概念是不容许的。(指针常量定义的时候对其举办初始化,右定向,必须内定指针指向)
int const
*px;这种概念是允许的。(常指针能够再定义的时候不初阶化,左定值,能够不赋初值)


以 const 申明的变量的指针只可以分配给同不经常间注脚为 const的指针。

  答案与深入分析:

  1. 在const成员函数中,用mutable修饰成员变量名后,就能够修改类的分子变量了。

const
 限定三个变量不容许被改变,可抓好程序安全性,利于别人领悟程序。该关键字也设有于C++、PHP5、C#语言中。

const
推出的发端目标,正是为了代替预编写翻译指令,解决它的毛病,同期继续它的帮助和益处。

  纵然那听上去不会细小略,但骨子里,const的行使也是c语言中叁个相比神秘的地点,微妙在何方呢?请看下边多少个难点。

5)指针指向的变量的值不可变,指向不可变

例:以下顺序会有一处报错

   

  const pStr p2 = string;

const定义常量从汇编的角度来看,只是给出了对应的内部存款和储蓄器地址,并非像#define一样付出的是当下数,所以,const定义的常量在程序运转进程中独有一份拷贝,而#define定义的常量在内部存款和储蓄器中有多少份拷贝。

double i=Pi; //此时为Pi分配内部存款和储蓄器,今后不再分配! 

  const char *p1 = string;

const只修饰其后的变量,至于const放在类型前依旧项目后并从未分别。如:const
int a和int const a都是修饰a为const。
3)指针指向的变量的值不能变,指向可变(左定值)

int
GetX()const

  为何作者象上边包车型客车事例同样用三个const变量来初阶化数组,ANSI
C的编写翻译器会报告一个不当吧?

4)指针指向的变量的值能够变动,指向不可变(右定向)

const
int function(); //此时const无意义

  2)、const在前面,与地点的申明对等

2)const在背后,与地点的注脚对等

改写成:

  char string[4] = “abc”;

int x = 1;
int y = 2;
int* const px = &x;
px = &y; //错误,不允许改变指针指向
*px = 3; //正确,允许改变指针指向的变量的值

再重复编译,就从不难题了。

  1)、const在前面

来自
<>

  const (char *) pContent;//pContent是const,*pContent可变

int const nValue; //nValue是const
char const * pContent; //*pContent是const, pContent可变
char* const pContent; //pContent是const,*pContent可变
char const* const pContent; //pContent和*pContent都是const

(1)可以定义const常量,具备不可变性。 

 

typedef char * pStr;
char string = "bbc";
const char *p1 =" string"; //1式
const pStr p2 =" string"; //2式
p1++;
p2++;

实际上,const成员函数还恐怕有别的一项效率,即常量对象相关。对于内置的数据类型,我们能够定义它们的常量,用户自定义的类也一直以来,能够定义它们的常量对象。举个例子,定义一个整型常量的章程为:

  3)、替换1式char, const newType m;

改编自
http://baike.sogou.com/v64494396.htm?fromTitle=CONST
http://blog.csdn.net/lihao21
http://blog.sina.com.cn/s/blog\_79b01f6601018xdg.html

const成员函数和const对象

  const char *pContent; //*pContent是const, pContent可变

1)值得注意的是,把三个分子函数注明为const能够保险这几个成员函数不更动数据成员,然而,借使据成员是指针,则const成员函数能够修改指针指向的指标。
2)const成员函数能够访谈非const对象的非const数据成员、const数据成员,也能够访问const对象内的享有数据成员;
3)非const成员函数可以访问非const对象的非const数据成员、const数据成员,但不可以访谈const对象的自由数据成员;
4)作为一种优质的编制程序风格,在宣称贰个成员函数时,若该成员函数并不对数据成员开始展览改动操作,应竭尽将该成员函数评释为const
成员函数。

const
pStr p2 = string; //2式

  const char* const pContent; //pContent和*pContent都是const

int x = 1;
int y = 2;
const int* const px = &x;
int const* const px = &x;
px = &y; //错误,不允许改变指针指向
*px = 3; //错误,不允许改变指针指向的变量的值

题目出在p2++上。

  下边包车型客车代码编写翻译器会报三个荒谬,请问,哪二个话语是不当的啊?

枚举常量不会占用对象的存储空间,它们在编译时被全部求值。枚举常量的缺点是:它的隐含数据类型是整数,其最大值有限,且不能表示浮点数(如PI=3.14159)。sizeof(A) = 1200;其中枚举部长空间。
```enum   EM { SIZE1 = 100, SIZE2 = 200}; // 枚举常量    sizeof(EM) = 4;```