C/C++面试(2)——const

1.const修饰指针或变量，防止定义的对象再次被修改

原文：http://blog.csdn.net/jamestaosh/article/details/4348726

const变量 & const 限定的内容
下面的代码编译器会报一个错误，请问，哪一个语句是错误的呢？
　　typedef char * pStr;
　　char string[4] = "abc";
　　const char *p1 = string;
　　const pStr p2 = string;
　　p1++;
　　p2++; 
答案与分析：
问题出在p2++上。
1)const使用的基本形式： const char m; 限定m不可变。
2)、替换1式中的m, const char *pm; 限定*pm不可变，当然pm是可变的，因此问题中p1++是对的。
3)、替换1式char, const newType m; 限定m不可变，问题中的charptr就是一种新类型，因此问题中p2不可变，p2++是错误的。


const & 指针
类型声明中const用来修饰一个常量，有如下两种写法，那么，请问，下面分别用const限定不可变的内容是什么?
1)const在前面
const int nValue； //nValue是const
const char *pContent; //*pContent是const, pContent可变
const (char *) pContent;//pContent是const,*pContent可变
char* const pContent; //pContent是const,*pContent可变
const char* const pContent; //pContent和*pContent都是const 
2)、const在后面，与上面的声明对等
int const nValue； // nValue是const
char const * pContent;// *pContent是const, pContent可变
(char *) const pContent;//pContent是const,*pContent可变
char* const pContent;// pContent是const,*pContent可变
char const* const pContent;// pContent和*pContent都是const 
答案与分析：
　const和指针一起使用是C语言中一个很常见的困惑之处，在实际开发中，特别是在看别人代码的时候，常常会因为这样而不好判断作者的意图。
    助记法：
Bjarne在他的The C++ Programming Language里面给出过一个助记的方法：把一个声明从右向左读。 
　　char * const cp; ( * 读成 pointer to ) ：cp is a const pointer to char 
　　const char * p; ：p is a pointer to const char; 
　　char const * p; 
　　同上因为C++里面没有const*的运算符，所以const只能属于前面的类型。

下面定义的一个指向字符串的常量指针： 
char * const prt1 = stringprt1; 
其中，ptr1是一个常量指针。因此，下面赋值是非法的。 ptr1 = stringprt2; 
而下面的赋值是合法的： *ptr1 = "m"; 
因为指针ptr1所指向的变量是可以更新的，不可更新的是常量指针ptr1所指的方向(别的字符串)。

下面定义了一个指向字符串常量的指针： 
const char * ptr2 = stringprt1; 
其中，ptr2是一个指向字符串常量的指针。ptr2所指向的字符串不能更新的，而ptr2是可以更新的。因此， 
*ptr2 = "x"; 是非法的，而： ptr2 = stringptr2; 是合法的。 
所以，在使用const修饰指针时，应该注意const的位置。定义一个指向字符串的指针常量和定义一个指向字符串常量的指针时，const修饰符的位置不同，前者const放在*和指针名之间，后者const放在类型说明符前。

接下来，参考：http://blog.csdn.net/bizhu12/article/details/6672723

2. 保护传参时参数不被修改,如果使用引用传递参数或按地址传递参数给一个函数,在这个函数里这个参数的值若被修改,
则函数外部传进来的变量的值也发生改变,若想保护传进来的变量不被修改,可以使用const保护

 void  fun1(const int &val)

  {

     //val = 10; //出错

}

void fun2(int &val)

{

   val = 10; //没有出错

}

void main()

{

   int a = 2;

   int b = 2;

   fun1(a); //因为出错,这个函数结束时a的值还是2

   fun2(b);//因为没有出错,函数结束时b的值为10

}

如果只想把值传给函数,而且这个不能被修改,则可以使用const保护变量,有人会问为什么不按值传递,按值传递还需要把这个值复制一遍,

而引用不需要,使用引用是为了提高效率//如果按值传递的话,没必要加const,那样根本没意义

 

3. 节约内存空间

 #define  PI  3.14 //使用#define宏

 const double Pi = 3.14 //使用const,这时候Pi并没有放入内存中

 

 double  a = Pi;  //这时候才为Pi分配内存,不过后面再有这样的定义也不会再分配内存

 double  b = PI;  //编译时分配内存

 double  c = Pi;  //不会再分配内存,

 double  d = PI;  //编译时再分配内存

const定义的变量,系统只为它分配一次内存,而使用#define定义的常量宏,能分配好多次,这样const就很节约空间

 

4.类中使用const修饰函数防止修改非static类成员变量

 class

{

 public:

  void fun() const //加const修饰

   {

     a = 10; //出错,不可修改非static变量

     b = 10; //对,可以修改

}

 private:

  int  a ;

  static int b;

}

5.修饰函数返回值,防止返回值被改变

  const int fun();
  接收返回值的变量也必须加const
  const int a = fun(); //接收的变量也要是const的,int a = fun()是错误的
 

6.修饰类的成员变量

  使用const修饰的变量必须初始化,在类中又不能在定义时初始化,
如;
class
{
private:
  int a = 10;
  const int b = 10;
  static const int c = 10;
//这样初始化都是错的,
}
 
初始化const int类型(没有static),在类的构造函数上初始化
Class Test
{
Public:
  Test():b(23) //构造函数上初始化b的值为23
   {
}
private:
     const int b ;
}
 
初始化staticconst int这个类型的(带有static的),在类的外面初始化
class Test
{
private:
  static const int c;
} 
const int Test::c=10; //类的外部初始化c为10
 

7.const定义的对象变量只能作用于这个程序该C/C++文件,不能被该程序的其他C/C++文件调用

 如file1.cpp中 const int val;
 在file2.cpp中, extern intval; //错误,无法调用,
要想const定义的对象变量能被其他文件调用,定义时必须使用extern修饰为
extern const int val;
 
非const变量默认为extern,要是const能被其他文件访问必须显示指定为extern