前往我的博客阅读体验更佳：
本文链接
1. const定义变量
1.1 定义常量
由于常量定义后无法更改，
所以定义时必须初始化！！！
1.2 类型检查
const常量编译时编译器会进行类型检查，#define宏定义只是字符串替换，没有安全检查，所以应该使用const定义常量。
1.3 extern
要使const变量在其他文件中访问，必须在文件中显式的指定为extern。
-
未被const修饰的变量在不同文件的访问
// file1.cpp int ext; // file2.cpp #include<iostream> extern int ext; int main() { std::cout << (ext + 10) << std::endl; } -
被const修饰的变量在不同文件的访问
//extern_file1.cpp extern const int ext = 12; //extern_file2.cpp #include<iostream> extern const int ext; int main() { std::cout << ext << std::endl; }{% note success %}
未被const修饰的变量不需要extern显式声明！而const常量需要显式声明extern，并且需要做初始化！
{% endnote %}
2. 指针与const
与指针有关的const用法有如下四种：
const char *a1; //指向const对象的指针或者说指向常量的指针。
char const *a2; //同上
char *const a3 = NULL; //指向类型对象的const指针。或者说常指针、const指针。
const char *const a4 = NULL; //指向const对象的const指针。
{% note success %}
如果
const
位于
*
的左侧，则const就是用来修饰指针所指向的变量，即
指针指向为常量
；
如果
const
位于
*
的右侧，则const就是修饰指针本身，即
指针本身是常量
。
{% endnote %}
2.1 指向常量的指针
const int *ptr;
*ptr = 10; //error
该定义说明ptr指针是可变的，其所指向的对象是被const修饰，是常量，不可变。
非const对象的地址可以赋值给指向const对象的指针
int a = 101;
const int *p;
p = &a; //ok
*p = 1; //error
std::cout<<*p<<std::endl;
p为一个指向const对象的指针，它可以指向非const对象a，但是不能通过p指针来修改a的值，可以通过其他方式修改，比如：
int a = 101;
const int *p;
p = &a; //ok
//*p = 1; //error
std::cout << *p << std::endl;
int *p1 = &a;
*p1 = 102; //ok
std::cout << *p1 << std::endl;
2.2 常指针
int num = 0;
int *const ptr = # //const指针必须初始化！且const指针的值不能修改
cout << *ptr << endl;
int *t = #
*t = 1;
cout << *ptr << endl;
常指针必须初始化，且const指针的值不能修改。
可以通过非const指针更改const指针指向的值。
由于ptr指向的是一个变量，当把const变量的地址赋给ptr时会报错，如图
应该将ptr定义改为
const int *ptr
或
const int * const ptr
。
3. 函数中使用const
3.1 const修饰函数返回值
跟const修饰普通变量和指针的含义相同。
-
const int
const int func1();无意义，函数返回值就是赋值给其他变量。
-
const int*
const int* func2();指针指向的内容不变。
-
int *const
int *const func2();指针本身不可变。
3.2 const修饰函数参数
-
传递过来的参数及指针本身在函数内不可变，
无意义
void func(const int var); // 传递过来的参数不可变 void func(int *const var); // 指针本身不可变表明参数在函数体内不能被修改，但其实没有意义，因为var采用“值传递”，传入函数内部会复制到一个临时变量中，本身就不会被更改，传入的形参是指针也一样。
-
参数指针所指内容为常量不可变
若函数的功能需要返回多个值，在需要在函数参数中以地址传递的形式传入参数，但是输入参数不希望在函数内部被不小心更改，此时加入const修饰。
void StringCopy(char *dst, const char *src);如上所示，dst是输出参数。src是输入参数，不希望更改，加上const修饰后，若在函数内部试图更改src所指向对象的内容，编译器将会报错。
-
参数为引用，
增加效率同时防止修改
对于非内部数据类型的参数而言，像
void func(A a)
这样声明的函数注定效率比较低。因为函数体内将产生A类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。为了提高效率，可以将函数声明改为
void func(A &a)
，因为“引用传递”仅借用参数的别名而已，不需要产生临时对象。但是“引用传递”有可能会更改参数的值，因此需要使用const进行修饰，即函数应该声明为
void func(const A &a)
。
由于内部数据类型的输入参数不存在构造、析构的过程，“值传递”和“引用传递”的效率几乎相当，不需要改写。
4. 类中使用const
4.1 const成员变量
对于类中的const成员变量必须通过初始化列表进行初始化，如下所示：
class Apple{
public:
Apple(int i);
const int apple_number;
};
Apple::Apple(int i):apple_number(i)
{
}
若所有对象的常变量都一样，也可以利用下面方法初始化：
//.h文件
static const int apple_number;
//.cpp文件
const int Apple::apple_number = 10;
4.2 const成员函数
声明方式为正常函数声明+const，const在函数声明末尾，如下所示：
int getCount() const;
const对象只能访问const成员函数，而非const对象可以访问任何成员函数。
4.3 常对象
使用const修饰的对象，只能访问const成员函数。
//test1.cpp
class Apple {
private:
int _weight;
public:
Apple(int weight) {
_weight = weight;
};
int getW();
int getWeight() const;
};
//main.cpp
#include <iostream>
#include "test1.cpp"
using namespace std;
int main() {
Apple a(2);
const Apple b(3);
a.getWeight();
b.getWeight();
a.getW();
b.getW();//error
}
上述const对象b调用非const成员函数getW()报错。
本文为学习
C++那些事 (github.com)
所记笔记。