结论

• 未被const修饰的变量不需要extern显式声明，而const常量需要显式声明extern！
• const修饰的变量必须初始化！
• const *表示指针指向为常量，* const表示指针本身是常量！
• 对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void func(A a) 改为void func(const A &a)。而对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void func(int x) 不应该改为void func(const int &x)。
• 使用const关键字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象，没有使用const关键字的成员函数不能用来操作常对象。

1、const含义

常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。

这里的对象是广义的对象，不单单指类的对象。比如int a = 3，此处a也可以称为对象，通常将之称之为普通对象。

2、const作用

2.1、可以定义常量

const int a=100;

  

 

  
1
 

const 定义的变量只有类型为整数或枚举，且以常量表达式初始化时才能作为常量表达式。其他情况下它只是一个 const 限定的变量，不要将与常量混淆。

2.2、类型检查

const常量与#define宏定义常量的区别 - 是否进行安全检查：

• const常量具有类型，编译器可以进行安全检查；
• #define宏定义没有数据类型，只是简单的字符串替换，不能进行安全检查。

勘误：此处的错误在于 #define 定义的宏常量（假设它不是花括号初始化器列表）同样存在类型。
例如若写 #define FOURTY_TWO 42 ，则 FOURTY_TWO 的类型是 int 。具体的类型和各种字面量（整数、浮点、用户定义等）和运算符的结果类型有关。

2.3、防止修改，起保护作用，增加程序健壮性

void f(const int i){
    i++; //error!
}

  

 

  
1
  
2
  
3
 

2.4、可以节省空间，避免不必要的内存分配

const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。

勘误：此处的错误在于，若用 const 定义常量（类型为整数或枚举，必须以常量表达式初始化），则这种常量在非 odr 式使用（粗略来说是只使用其值）时不需要依赖其身为变量的身份，一定场合下甚至可以不需要定义（譬如作为类的 static 成员对象）。
编译器在作为常量处理它时，不会依赖“一份定义”，而是像是立即数一样使用它，它本身可能在机器码中被“拷贝”到多个地方，和 #define 定义的宏常量的结果相同。
另一方面， const 定义的常量由于是整数或枚举，所以直接变成机器码上的立即数往往性能更好。

3、const对象默认为文件局部变量

注意：非const变量默认为extern。要使const变量能够在其他文件中访问，必须在文件中显式地指定它为extern。

（1）未被const修饰的变量在不同文件的访问

// file1.cpp
int ext;

// file2.cpp
#include<iostream>
extern int ext;
int main(){
    std::cout<<(ext+10)<<std::endl;
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
 

（2）const常量在不同文件的访问

// file1.cpp
extern const int ext=12;

// file2.cpp
#include<iostream>
extern const int ext;
int main(){
    std::cout<<(ext+10)<<std::endl;
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
 

【3】小结：可以发现未被const修饰的变量不需要extern显式声明！而const常量需要显式声明extern，并且需要做初始化！因为常量在定义后就不能被修改，所以定义时必须初始化。

4.定义常量

const int b = 10;
b = 0; // error: assignment of read-only variable ‘b’
const string s = "helloworld";
const int i,j=0 // error: uninitialized const ‘i’

  

 

  
1
  
2
  
3
  
4
 

上述有两个错误

• 1、b为常量，不可更改！
• 2、i为常量，定义时必须进行初始化！

5、指针与const【重点】

指针相关的const有三种：

• 指向常量的指针
• 常指针
• 指向常量的常指针

const char * a; //指向const对象的指针（指向常量的指针）
char const * a; //指向const对象的指针（指向常量的指针）
char * const a; //指向类型对象的const指针（常指针、const指针）
const char * const a; //指向const对象的const指针（指向常量的常指针）

  

 

  
1
  
2
  
3
  
4
 

【5】小结：如果const位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。

5.1、指向常量的指针

const int *ptr;
*ptr = 10; //error

  

 

  
1
  
2
 

思考两个问题：
1、这里ptr前有const修饰，为什么不进行赋值？
答：ptr是指向常量的指针，放到本例即ptr是指向int类型const对象的指针。const修饰的是int类型，也就是ptr所指向的对象类型，而不是ptr本身，所以ptr不用赋初值！

2、为什么*ptr会报错？
答：ptr所指对象是const修饰的，不能修改该对象值！

【5.1】小结：对于指向常量的指针，不能通过指针来修改对象的值。

【对于常量指针还有两点需要补充的】

• 1、不能使用void*指针保存const对象的地址，必须使用const void*类型的指针保存const对象的地址。示例如下：

const int p = 10;
const void * vp = &p;
void *vp = &p; //error

  

 

  
1
  
2
  
3
 

• 2、允许把非const对象的地址赋值给const对象的指针（即指向常量的指针），如果要修改指针所指向的对象值，不能直接通过当前指针直接修改，但是可以通过不加const的指针修改！示例如下：

int val = 3;

const int *ptr = &val;
*ptr = 4; //error

int *ptr1 = &val;
*ptr1 = 4; //ok

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
 

5.2、常指针

常指针必须进行初始化，且常指针的值不能修改。

int num=0;
int num1=1;

int * const ptr=# //const指针必须初始化！且const指针的值不能修改
int * t = #

t = &num1; //ok
ptr = &num1; //error

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
 

【对于常指针还需要补充的】

• 当把一个const常量的地址赋值给常指针的时候，由于常指针指向的是一个变量，而不是const常量，此时会报错。若将常指针修改为指向常量的指针或者指向常量的常指针，均可以正常。示例如下：

const int num=0;

int * const ptr=# //error! const int* -> int*
const int * ptr1 = # //ok
const int * const ptr2 = # //ok

  

 

  
1
  
2
  
3
  
4
  
5
 

5.3、指向常量的常指针

理解完前两种情况，下面这个情况就比较好理解了，示例如下：

const int p = 3;
const int * const ptr = &p; 

  

 

  
1
  
2
 

ptr是一个常指针，然后指向了一个int 类型常量。

6、函数中使用const

6.1、cost修饰函数返回值

这个跟const修饰普通变量以及指针的含义基本相同

（1）const int

const int func1();

  

 

  
1
 

函数返回为常量。这个本身无意义，因为参数返回就是要赋值给其他的变量！

（2）const int*

const int* func2();

  

 

  
1
 

指针指向的内容不变。

（3）int *const

int *const func2();

  

 

  
1
 

指针本身不可变。

6.2、const修饰函数参数

在该部分将会解决两个面试问题：

• （1）如果函数需要传入一个指针，是否需要为该指针加上const，把const加在指针不同的位置有什么区别；
• （2）如果写的函数需要传入的参数是一个复杂类型的实例，传入值参数或者引用参数有什么区别，什么时候需要为传入的引用参数加上const。

（1）传递过来的参数及指针本身在函数内不可变，无意义！

void func(const int var); // 传递过来的参数不可变
void func(int *const var); // 指针本身不可变

  

 

  
1
  
2
 

表明参数在函数体内不能被修改，但此处没有任何意义，var本身就是形参，在函数内不会改变。包括传入的形参是指针也是一样。输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。

（2）参数指针所指内容为常量不可变（实用）

void StringCopy(char *dst, const char *src);

  

 

  
1
 

其中src 是输入参数，dst 是输出参数。给src加上const修饰后，如果函数体内的语句试图改动src的内容，编译器将指出错误。这就是加了const的作用之一。

（3）参数为引用，为了增加效率同时防止修改。

对于非内部数据类型的参数而言，像void func(A a) 这样声明的函数注定效率比较低。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。为了提高效率，可以将函数声明改为void func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数void func(A &a) 存在一个缺点：“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为：

void func(const A &a)

  

 

  
1
 

以此类推，是否应将void func(int x) 改写为void func(const int &x)，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，**“值传递”和“引用传递”**的效率几乎相当。

【6.2】小结：对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void func(A a) 改为void func(const A &a)。而对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void func(int x) 不应该改为void func(const int &x)。

7、类中使用const

在一个类中，任何不会修改数据成员的函数都应该声明为const类型。这样如果在编写const成员函数时，不慎修改数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。

使用const关键字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象，没有使用const关键字的成员函数不能用来操作常对象。

7.1、对于类中的const成员变量必须通过初始化列表进行初始化

C++类中成员变量的初始化总结

示例代码，如下所示：

class Apple
{
private:
    int people[100];
public:
    Apple(int i); 
    const int apple_number;
};

Apple::Apple(int i):apple_number(i)
{

}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
 

7.2、const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数

示例代码，如下所示：

//main.cpp
#include<iostream>
using namespace std;

class Apple
{
private:
    int people[100];
public:
    Apple(int i);
    const int apple_number;
    void take(int num) const;
    void add(int num);
    void add(int num) const;
    int getCount() const;

};

Apple::Apple(int i):apple_number(i)
{

}
void Apple::add(int num){
    cout<< "进入非const成员函数"<<endl;
    take(num);
}
void Apple::add(int num) const{
    cout<< "进入const成员函数"<<endl;
    take(num);
}
void Apple::take(int num) const
{
    cout<<"take func "<<num<<endl;
}
int Apple::getCount() const
{
    take(1);
//    add(); //error
    return apple_number;
}
int main(){
    Apple a(2);
    cout<<a.getCount()<<endl;
    a.add(10);
    const Apple b(3);
    b.add(100);
    return 0;
}

//结果
take func 1
2
进入非const成员函数
take func 10
进入const成员函数
take func 100

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
 

• getCount()方法中调用了一个add方法，而add方法并非const修饰，所以运行报错。也就是说const对象只能访问const成员函数。
• add方法又调用了const修饰的take方法，证明了非const对象可以访问任意的成员函数,包括const成员函数。
• add的一个重载函数，也输出了两个结果，说明const对象默认调用const成员函数。

7.3、其他初始化const常量的方法

除了上述的初始化const常量用初始化列表方式外，也可以通过下面方法：

第一：将常量定义与static结合，也就是：

static const int apple_number

  

 

  
1
 

第二：在外面初始化：

const int Apple::apple_number=10;

  

 

  
1
 

当然，如果你使用c++11进行编译，直接可以在定义时初始化，可以直接写成：

static const int apple_number=10;
或者
const int apple_number=10;

  

 

  
1
  
2
  
3
 

这两种都在c++11中支持！编译的时候加上-std=c++11即可！

这里提到了static，下面简单的说一下：
在C++中，static静态成员变量不能在类的内部初始化。在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化。在类中声明：static int ap;。在类实现文件中使用：int Apple::ap=666。对于此项，c++11不能进行声明并初始化，也就是上述使用方法。

文章来源: recclay.blog.csdn.net，作者：ReCclay，版权归原作者所有，如需转载，请联系作者。

原文链接：recclay.blog.csdn.net/article/details/108036637