C++ const 详解

大家好，欢迎来到IT知识分享网。

文章来源：

http://blog.csdn.net/shift_wwx/article/details/

请支持原创~~

0. 前言

const在C/C++中重要性很大，如果单纯理解为“常量”那就错了，这一篇总结一下C++中const的详细的用法。

1. const 修饰变量

它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性。

const int a; // a 代表一个常整型数 int const a; // a 代表一个常整型数 const int *a; // a 代表一个指向常整型数的指针，即a的值是可变的，但是*a是不能变的，函数的一些形参经常会用到 int * const a; // a 代表一个常指针，即a的值是不可变的，但是*a是可变的 int const * a const; // a代表的是一个指向常整型数的常指针

主要看const修饰的是什么？

1.1 const + 类型

说明const修饰的是类型，想让类型为常量，也就是这个类型的值为常量。

例如 const int *a; 本来是定义一个指针变量，指针变量所指向的值为 int 类型。const修饰 int 类型，那也就是说这个 int 类型的值为常量，也就是说指针指向的值为常量。

1.2 const + 变量

说明const修改的变量，想让这个变量为常量。

例如 int *const a; 本来是定义一个指针变量，指针变量所指向的值为 int 类型。const修饰变量，

1.3 const 与 指针

int a = 20; const int * p = &a;

上面定义了一个常指针，指向的数据 a 是不变的。即不能修改 *p 的值。

*p += 1; //INVALID coin >> *p; //INVALID

a = 30; //VALID

const int a = 20; int *p = &a; //INVALID

const int* p = &a; //VALID

如果将指针指向指针，则情况将更复杂一点。上面讲到如果是一级间接关系，可以将非const的指针赋给const的指针。例如，

int a = 10; int *p = &a; cont int *pt = p;

const int p2; int *p1; const int a = 20; p2 = &p1; //这里是不被允许的，编译的时候会报错 *p2 = &a; *p1 = 10;

1.4 尽可能的使用const

将指针参数声明为指向常量数据的指针有两个理由：

• 这样可以避免由于无意间修改数据而导致的编程错误；
• 使用const 使得函数能够处理const 和非const 实参，否则只能接受非const 数据。

例如，

有个常量数据array定义如下，

const int array [] = {1, 2, 3, 4, 5};

有个函数func定义如下，

void func(int array[], int n) { ... }

将上面常量数组作为参数传入，是不允许的，需要将参数改为 const。

2. const 修饰函数

2.1 const 修饰函数参数

如果函数作为输出用，不论是什么数据类型，也不论采用指针传递还是引用传递，都不能加 const 修饰，否则参数会失去输出功能。

const 只能修饰 输入作用 的参数。

void StringCopy(char* strDest, const char* strSource);

这里 strSource 加上const 修饰，就是为了防止 strSource 会被意外的修改。实参中指针指向一段内存地址，调用函数之后，函数会产生一个临时指针变量，这个变量的地址肯定跟实参的指针地址不一样，但是这两指针指向的内存是同一块。形参加上const 修饰之后，保护了这一块内存地址不被修改，如果刻意修改这一块内存，编译器会报错。

如果输入参数为引用，加上const 之后不但起到了保护作用，也提高了程序效率。
例如，

void func(A a); //这里的A类型为用户定义的类型

当然，不是所有的数据类型都需要用应用，例如，

void func(int x);

对于内部类型的参数，不存在构造、析构的过程，产生临时变量、值的复制过程很快，无需用引用。

2.2 const 修饰函数返回值

如果是值传递，没有必要将返回值用const 修饰，例如，

const int func();

函数的返回值为一个int 类型的值，这个只是个临时的值，没有必要用 const 修饰，最终这个值会复制给接受它的变量。

如果返回值为引用，同上面形参，都可以提高效率。但是一般返回引用的地方并不是很多，一般会出现在类的赋值函数中。而且，用const 修饰返回值为引用类型的更少。

如果返回值为指针，加上const修饰之后，同样的内容是不能修改的。不过有一点需要注意，接受的变量也必须是const 修饰。例如，

const char* func(); char* str = func();

上面这样调用是不对的，需要将变量str 用const修饰，改为：const char* str = func();

2.3 const  修饰成员函数

class MyClass { public: void func(int x) const; };

const 函数的几个规则：

• const 对象只能访问const 成员函数，非const 的对象可以访问任何成员函数，包括const 成员函数。
• 如果函数名、参数、返回值都相同的const成员函数和非const成员函数是可以构成重载，那么const对象调用const成员函数，非const对象默认调用非const的成员函数。
• const成员函数可以访问所有成员变量，但是只能访问const的成员函数。
• 非const成员函数，可以访问任何成员，包括const成员成员函数。
• const成员函数不能修改任何的成员变量，除非变量用 mutable修饰。

这一点可以理解为，在const 的成员函数中成员变量都变成 const 属性，无法再次修改。如果函数的返回类型为此成员变量的引用，那必须也要加上const修饰。例如，

class MyClass { public: int & func() const { return value; } private: int value; };

value为成员变量，func函数为 const 成员函数，如果要返回 value 的引用，这里的func函数返回值必须要加上const，改为，

const int& func() const { return value; }

当然，还有其他修改方法：

• 把int value 改成mutable int value。mutable修饰的变量使之在const函数中可以被改变的；
• return value 改成。 return const_cast(value)。const_cast去掉了const性质；
• 把引用去掉，写成返回值类型的；
• 把函数后面的const去掉；

3. 实例说明

#include "test.h" class Test9 { public: Test9() : vTest1(1), vTest2(1) { cout << "Test9 constructor.\n"; } ~Test9() { cout << "Test9 destructor.\n"; } void test1(); void test2() const; void funcForTest9(const int *); //int &test6()const { return vTest1; }//const成员函数中的成员变量变为const 修饰，返回值必须要要const private: void test3() { cout << "Test9 test3()\n"; } void test4() const { cout << "Test9 test4()\n"; } void test5() { cout << "Test9 test5().\n"; } void test5() const { cout << "Test9 test5()const.\n"; } void test6(); int vTest1; const int vTest2; }; void Test9::test1() { cout << "Test9 test1.\n"; cout << "value of vTest1 is " << vTest1 << endl; cout << "value of vTest2 is " << vTest2 << endl; vTest1 = 10;//普通成员函数是可以修改成员变量 //const 和非const的成员函数都可以访问 test3(); test4(); test5();//调用的是非const的成员函数 /*cout << endl; test6();*/ } void Test9::test2() const{ cout << "Test9 test2.\n"; cout << "value of vTest1 is " << vTest1 << endl; cout << "value of vTest2 is " << vTest2 << endl; //vTest1 = 10;//const成员函数不能修改成员变量 //test3();//const成员函数只能访问const函数，不能访问非const的成员函数 test4(); test5();//调用的是const的成员函数 } void Test9::funcForTest9(const int* x) {//这里参数表示x指向的值不能修改 cout << "address of pointer x is " << &x << endl; cout << "pointer x is " << x << endl;//这里跟实参是一个地址 cout << "value of pointer x is " << *x << endl;//这里是实参的值 int a = 20; cout << "\naddress of a is " << &a << endl; //*x = a; //编译器会报错，左值必须是可修改的 x = &a;//代表着之前的*x不能修改，x可以修改 cout << "address of pointer x is " << &x << endl; cout << "pointer x is " << x << endl; cout << "value of pointer x is " << *x << endl; } void Test9::test6() { const int p2; cout << "address of p2 is " << &p2 << endl; cout << "value of p2 is " << p2 << endl; int *p1; cout << "address of p1 is " << &p1 << endl; cout << "value of p1 is " << p1 << endl; const int a = 10; cout << "address of a is " << &a << endl; cout << "value of a is " << a << endl; //p2 = &p1; //二级间接关系，是不允许非const 指针赋给const指针 cout << "address of p2 is " << &p2 << endl; cout << "value of p2 is " << p2 << endl; *p2 = &a; cout << "address of p2 is " << &p2 << endl; cout << "value of p2 is " << p2 << endl; cout << "value of *p2 is " << *p2 << endl; cout << "address of p1 is " << &p1 << endl; cout << "value of p1 is " << p1 << endl; *p1 = 10; } void Test::test9() {//这里是给main调用的入口函数 int x = 10; cout << "address of x is " << &x << endl; int *p = &x; cout << "address of pointer p is " << &p << endl; cout << "pointer p is " << p << endl; cout << "value of pointer p is " << *p << endl; cout << endl; Test9 obj; obj.funcForTest9(p); cout << endl; obj.test1(); cout << endl; const Test9 obj_1; //obj_1.test1();//const对象，不能访问非const成员函数。 cout << endl; obj_1.test2(); //obj_1.vTest1 = 10;//不可以访问const 对象的任何成员 }