C++中const详细用法

1.const 修饰数据

    const int num = 1; // 必须初始化
    //int const test1 = 1; //等同于const int test1 = 1;
    // test1 = 2;  //错误：向只读变量‘test1’赋值
    double a[num] = {10}; //C++ 可行

 2.const修饰指针：注意修饰指针指向的数据，还是修饰指针的地址

    int *p200  = &num20; 
    //int *p210 = &num21;    / /error: 从类型‘const int*’到类型‘int*’的转换无效
    //2.1 修饰指针指向数据
    const int *p201 = &num20; //const 修饰的数据 不是地址 
    const int *p211 = &num21; 
    int const * p221 = &num21; //const 与int的顺序无关
    //*p201 = 1; //数值不能被修改
    //*p211 = 2; //数值不能被修改
    p211 = p201;  //地址可以被修改,说明const修饰的不是地址
    p201 = p211;
    //2.2 修饰指针地址
    int* const p202 = &num20;
    //int* const p212 = &num21;错误
    int*p212 = &num20;
    //p202 = p212; //const修饰的地址，不能被改变
    *p202 = 2; //数值可以被改变
     p212 = p202;   //地址可以赋与其他指针
    //2.3 修饰地址与指针
    const int* const  p203 = &num20; //数值，地址都变成常量，只保留可读形式
    const int* const p213 = &num21;
   // *p203 = 1; //数值不能改变
  //  p203 = p213;// 地址也不能改变

3.const 保护函数形参不被修改

void f3(const double a,const double b,double c)
{
    c = a + b; //success 可以改变c的数值
    //a = 11;    //error:使用const保护后，不能修改
}

4.const 保护函数的返回值不被修改

const double f31(const double a,const double b)
{
    double c = a + b;
    return c;
}
const double *f5(double *vec)
{
    return vec;
}
//主函数中
{
...
    //“值传递“，函数将自动产生临时变量用于复制该参数，因此const不管作用
    double rc = f31(10,20); 
    rc = 33;          
    //"指针传递"，传递的是地址，因此，const修饰有用
    //double *p1 = f5(a3); //错误
    const double *p1 = f5( a3 );     
    //"别名传递" 谨慎使用
   
}

5.const 修饰成员函数，表明该函数不会对成员数据有任何变化，只能读取数据，不能改变

class T1{
public:
...
    void f1()const; 
private:
	int a;
	int b;
	int c;
...
};
void T1::f1() const 
{
	//c = a + b; //error: ssignment of member ‘T1::c’ in read-only object
	cout << c << endl;
}

注意：

5.1.const 修饰的成员函数，当仅是否含有const时候，该成员函数是可以重载的；

5.2 非const对象调用仅重载const差别的成员函数时，首先调用非const成员函数，如果没有非const成员函数，才会调用const修饰的函数；

5.3const对象只能调用const修饰的函数；

5.4const修饰的成员变量，只能再初始化列表中进行初始化；

下面给出例子说明以上几点：

class T1{
public:
	T1():abc(100) //成员常量的赋值放只能在初始化列表之中进行
	{ a = 10;b = 20;c = 0;};
	~T1(){};
	void f1()const; 
	void f1();
    void f2();
private:
	int a;
	int b;
	int c;
	const int abc; //成员常量的赋值放只能在初始化列表之中进行
};
//T1::abcd = 100;
void T1::f1() const 
{
	//c = a + b; //error: ssignment of member ‘T1::c’ in read-only object
	cout << c << endl;
}
void T1::f1()
{
	c = a + b; 
	
	cout << c << endl;
}
void T1::f2()
{
	c = a + b;
	cout << c << endl;
}
//主函数中
int main()
{
    T1 t1;
    const T1 t2;
    t1.f1();  //调用非const修饰的成员函数
    t2.f1();  //调用const修饰的成员函数
    //t2.f2();  //error:不能调用非const的成员函数
    return 0;
}