目录

1. const

1.1 const修饰普通变量

默认状态下，const对象仅在文件内有效

1.2 const修饰引用

1.3 const修饰指针

1.3.1 * const p

1.3.2 const * p

1.3.3 const * const p

1.4 顶层const和底层const

1.5 用权限的方式理解const

2. constexpr

2.1 常量表达式

2.2 constexpr变量

2.3 字面值类型

2.4 指针和constexpr

2.5 constexpr函数

1. const

1.1 const修饰普通变量

const修饰的变量，本质是变量，但是不能直接修改，有常量的属性，称为常变量。

const float pi = 3.14f;
//float const pi = 3.14f;
pi = 5.14;//err

const修饰的常变量一旦创建后其值就不能再改变，所以必须初始化。

const int a;//err

如果利用一个变量去初始化另外一个变量，则它们是不是const都无关紧要。常变量的常量特征仅仅在执行改变常变量的操作时才会发挥作用。

int i = 42;
const int ci = i//ok
int j = ci;//ok

默认状态下，const对象仅在文件内有效

当以编译时初始化的方式定义一个const对象时，就如对bufSize的定义一样：

const int bufSize = 512; // 输入缓冲区大小

编译器将在编译过程中把用到该变量的地方都替换成对应的值。也就是说，编译器会找到代码中所有用到bufsize的地方，然后用512替换。

为了执行上述替换，编译器必须知道变量的初始值。如果程序包含多个文件，则每个用了const对象的文件都必须得能访问到它的初始值才行。要做到这一点，就必须在每一个用到变量的文件中都有对它的定义。为了支持这一用法，同时避免对同一变量的重复定义，默认情况下，const对象被设定为仅在文件内有效。当多个文件中出现了同名的const变量时，其实等同于在不同文件中分别定义了独立的变量。

某些时候有这样一种const变量，它的初始值不是一个常量表达式，但又确实有必要在文件间共享。这种情况下，我们不希望编译器为每个文件分别生成独立的变量。相反，我们想让这类const对象像其他（非常量）对象一样工作，也就是说，只在一个文件中定义const，而在其他多个文件中声明并使用它。

解决的办法是，对于const变量不管是声明还是定义都添加extern关键字，这样只需定义一次就可以了：

// file_1.cc定义并初始化了一个常量，该常量能被其他文件访问
extern const int bufSize = fcn();
// file_1.h头文件
extern const int bufsize; // 与file_1.cc中定义的bufSize是同一个

如上述程序所示，file_1.cc定义并初始化了bufsize。因为这条语句包含了初始值，所以它（显然）是一次定义。然而，因为bufsize是一个常量，必须用extern加以限定使其被其他文件使用。

file_1.h头文件中的声明也由extern做了限定，其作用是指明bufsize并非本文件所独有，它的定义将在别处出现。

如果想在多个文件之间共享const对象，必须在变量的定义之前添加extern关键字。

1.2 const修饰引用

const修饰的引用，称为常量引用或常引用。不能通过常量引用改变对应的对象的值。

const int ci = 10;
const int &r1 = ci;//ok r1是常量引用，对应的对象ci也是常量
r1 = 20;//err 不能通过常量引用改变对应的对象的值
int &r2 = ci;//err ci不能改变，当然也就不能通过引用去改变ci//假设合法，则可以通过r2来改变ci，这是不合法的

在初始化常量引用时允许用任意表达式作为初始值，只要该表达式的结果能转换成引用的类型即可。尤其，允许为一个常量引用绑定非常量的对象、字面值，甚至是个一般表达式。

int i = 50;
const int& r1 = i;//ok 将const int&绑定到一个普通int对象上
const int& r2 = 10;//ok 将const int&绑定到一个int字面值上
const int& r3 = r1 * 2;//ok 将const int&绑定到一个表达式上
int& r4 = r1 * 2;//err

我们要清楚当一个常量引用被绑定到另外一种类型上时到底发生了什么：

double pi = 3.14;
const int& rpi = pi;//ok 将const int&绑定到一个普通double对象上

为什么rpi能够绑定pi？为了让rpi绑定一个整型对象，编译器把代码处理为：

const int temp = pi;//隐式类型转换 double->const int
const int& rpi = temp;//让rpi绑定这个临时量

所以当一个常量引用被绑定到另外一种类型上时，常量引用绑定的其实是相同类型的临时量。

如果函数的返回值是一个值而非引用，那么返回的是一个临时变量，且具有常量性。如果要用引用接收该值，只能用常量引用。

int Count()
{static int n = 0;n++;return n;
}int& ret = Count();//err
const int& ret = Count();//ok

1.3 const修饰指针

1.3.1 * const p

const放在*的右边，修饰的是指针本身，指针是常量指针。

• 指针本身的值不能改变
• 指针指向的值可以改变

int m = 5;
int n = 10;
int* const p = &m;//p是常量指针
p = &n;//err 指针本身的值不能改变
*p = 0;//ok  指针指向的值可以改变

常量指针（const pointer）必须初始化，而且一旦初始化完成，则它的值（也就是存放在指针中的那个地址）就不能再改变了。

1.3.2 const * p

const放在*的左边，修饰的是指针指向的值，指针是指向常量的指针。

• 指针指向的值不能改变
• 指针本身的值可以改变

int m = 5;
int n = 10;
const int* p = &m;//p是指向常量的指针
//int const* p = &m;
*p = 0;//err 指针指向的值不能改变
p = &n;//ok  指针本身的值可以改变

1.3.3 const * const p

const放在*的左右两边，修饰的是既是指针本身，又是指针指向的值，指针是指向常量的常量指针。

• 指针本身的值不能改变
• 指针指向的值不能改变

const int n = 10;
const int* const p = &n;//p是指向常量的常量指针
p = &n;//err 指针本身的值不能改变
*p = 0;//err 指针指向的值不能改变

1.4 顶层const和底层const

如前所述，指针本身是一个对象，它又可以指向另外一个对象。因此，指针本身是不是常量以及指针所指的是不是一个常量就是两个相互独立的问题。用名词顶层const（top-level const）表示指针本身是个常量，而用名词底层const（low-level const）表示指针所指的对象是一个常量。

更一般的，顶层const可以表示任意的对象是常量，这一点对任何数据类型都适用，如算术类型、类、指针等。底层const则与指针和引用等复合类型的基本类型部分有关。比较特殊的是，指针类型既可以是顶层const也可以是底层const，这一点和其他类型相比区别明显：

int i = 0;
int* const p1 = &i; //顶层const，不能改变p1的值
const int ci = 42;  //顶层const，不能改变ci的值
const int* p2 = &ci;//底层const，可以改变p2的值
const int* const p3 = p2;//靠右的const是顶层const，靠左的是底层const
const int& r = ci;//用于声明引用的const都是底层const

当执行对象的拷贝操作时，常量是顶层const还是底层const区别明显。其中，顶层const不受什么影响：

i = ci; //ok 拷贝ci的值，ci是一个顶层const，对此操作无影响
p2 = p3;//ok p2和p3指向的对象类型相同，p3顶层const的部分不影响

执行拷贝操作并不会改变被拷贝对象的值，因此，拷入和拷出的对象是否是常量都没什么影响。

另一方面，底层const的限制却不能忽视。当执行对象的拷贝操作时，拷入和拷出的对象必须具有相同的底层const资格，或者两个对象的数据类型必须能够转换。一般来说，非常量可以转换成常量，反之则不行：

int* p = p3;//err p3包含底层const的定义，而p没有
p2 = p3;//ok p2和p3都是底层const
p2 = &i;//ok int*能转换成const int*
int &r = ci;//err 普通的int&不能绑定到int常量上
const int &r2 = i;//ok const int&可以绑定到一个普通int上

p3既是顶层const也是底层const，拷贝p3时可以不在乎它是一个顶层const，但是必须清楚它指向的对象得是一个常量。因此，不能用p3去初始化p，因为p指向的是一个普通的（非常量）整数。另一方面，p3的值可以赋给p2，是因为这两个指针都是底层const，尽管p3同时也是一个常量指针（顶层const），仅就这次赋值而言不会有什么影响。

1.5 用权限的方式理解const

const的功能是将权限缩小，从可读可写缩小到只读。

没有指针或引用时，无关权限，因为不涉及到修改对象的值。

const int m = 1;
int n = m;//ok

指针和引用，赋值/初始化时，权限可以保持或缩小，但是不能放大。

//权限放大 err
const int a = 2;
int& b = a;const int* p1 = nullptr;
int* p2 = p1;//权限保持 ok
const int c = 2;
const int& d = c;const int* p3 = nullptr;
const int* p4 = p3;//权限缩小 ok
int e = 1;
const int& f = e;int* p5 = nullptr;
const int* p6 = p5;

2. constexpr

2.1 常量表达式

常量表达式（const expression）是指值不会改变并且在编译过程就能得到计算结果的表达式。显然，字面值属于常量表达式，用常量表达式初始化的const对象也是常量表达式。

一个对象（或表达式）是不是常量表达式由它的数据类型和初始值共同决定，例如：

const int max_files = 20;       //max_files是常量表达式
const int limit = max_files + 1;//limit是常量表达式
int staff_size = 27;            //staff_size不是常量表达式
const int sz = get_size();      //sz不是常量表达式

尽管staff_size的初始值是个字面值常量，但由于它的数据类型只是一个普通int而非const int，所以它不属于常量表达式。另一方面，尽管sz本身是一个常量，但它的具体值直到运行时才能获取到，所以也不是常量表达式。

2.2 constexpr变量

在一个复杂系统中，很难（几乎肯定不能）分辨一个初始值到底是不是常量表达式。当然可以定义一个const变量并把它的初始值设为我们认为的某个常量表达式，但在实际使用时，尽管要求如此却常常发现初始值并非常量表达式的情况。可以这么说，在此种情况下，对象的定义和使用根本就是两回事儿。

C++11新标准规定，允许将变量声明为constexpr类型以便由编译器来验证变量的值是否是一个常量表达式。声明为constexpr的变量一定是一个常量，而且必须用常量表达式初始化：

constexpr int mf = 20;       //20是常量表达式
constexpr int limit = mf + 1;//mf +1是常量表达式
constexpr int sz = size();   //只有当size是一个constexpr函数时//才是一条正确的声明语句

尽管不能使用普通函数作为constexpr变量的初始值，但是新标准允许定义一种特殊的constexpr函数。这种函数应该足够简单以使得编译时就可以计算其结果，这样就能用constexpr函数去初始化 constexpr变量了。

一般来说，如果你认定变量是一个常量表达式，那就把它声明成constexpr类型。

2.3 字面值类型

常量表达式的值需要在编译时就得到计算，因此对声明constexpr时用到的类型必须有所限制。因为这些类型一般比较简单，值也显而易见、容易得到，就把它们称为字面值类型（literal type）。

算术类型、引用和指针都属于字面值类型。

尽管指针和引用都能定义成constexpr，但它们的初始值却受到严格限制。一个constexpr指针的初始值必须是nullptr或者0，或者是存储于某个固定地址中的对象。

函数体内定义的变量一般来说并非存放在固定地址中，因此constexpr指针不能指向这样的变量。相反的，定义于所有函数体之外的对象其地址固定不变，能用来初始化constexpr指针。允许函数定义一类有效范围超出函数本身的变量，这类变量和定义在函数体之外的变量一样也有固定地址。因此，constexpr引用能绑定到这样的变量上，constexpr指针也能指向这样的变量。

除了算术类型、引用和指针外，某些类也是字面值类型。和其他类不同，字面值类型的类可能含有constexpr函数成员。这样的成员必须符合constexpr函数的所有要求，它们是隐式const的。

聚合类（aggregate class）使得用户可以直接访问其成员，并且具有特殊的初始化语法形式。当一个类满足如下条件时，我们说它是聚合的：

• 所有成员都是public的。
• 没有定义任何构造函数。
• 没有类内初始值。
• 没有基类，也没有virtual函数。

数据成员都是字面值类型的聚合类是字面值常量类。如果一个类不是聚合类，但它符合下述要求，则它也是一个字面值常量类：

• 数据成员都必须是字面值类型。
• 类必须至少含有一个constexpr构造函数。
• 如果一个数据成员含有类内初始值，则内置类型成员的初始值必须是一条常量表达式；或者如果成员属于某种类类型，则初始值必须使用成员自己的constexpr构造函数。
• 类必须使用析构函数的默认定义，该成员负责销毁类的对象。

枚举属于字面值常量类型。

2.4 指针和constexpr

必须明确一点，在constexpr声明中如果定义了一个指针，限定符constexpr仅对指针有效，与指针所指的对象无关：

const int *p = nullptr;    //p是一个指向整型常量的指针
constexpr int *q = nullptr;//q是一个指向整数的常量指针

p和q的类型相差甚远，p是一个指向常量的指针，而q是一个常量指针，其中的关键在于constexpr把它所定义的对象置为了顶层const。

与其他常量指针类似，constexpr指针既可以指向常量也可以指向一个非常量：

constexpr int *np = nullptr;//np是一个指向整数的常量指针，其值为空
int j = 0;
constexpr int i = 42;       //i的类型是整型常量
//i和j都必须定义在函数体之外
constexpr const int *p = &i;//p是常量指针，指向整型常量i
constexpr int *p1 = &j;     //p1是常量指针，指向整数j

2.5 constexpr函数

constexpr函数（constexpr function）是指能用于常量表达式的函数。定义constexpr函数的方法与其他函数类似，不过要遵循几项约定：函数的返回类型及所有形参的类型都得是字面值类型，而且函数体中必须有且只有一条return语句：

constexpr int new_sz() { return 42; }
constexpr int foo = new_sz();//正确: foo是一个常量表达式

我们把new_sz定义成无参数的constexpr函数。因为编译器能在程序编译时验证new_sz函数返回的是常量表达式，所以可以用new_sz函数初始化constexpr类型的变量foo。

执行该初始化任务时，编译器把对constexpr函数的调用替换成其结果值。为了能在编译过程中随时展开，constexpr函数被隐式地指定为内联函数。

constexpr函数体内也可以包含其他语句，只要这些语句在运行时不执行任何操作就行。例如，constexpr函数中可以有空语句、类型别名以及using声明。

我们允许constexpr函数的返回值并非一个常量：

//如果arg是常量表达式，则scale(arg)也是常量表达式
constexpr size_t scale(size_t cnt) { return new_sz() * cnt; }

当scale的实参是常量表达式时，它的返回值也是常量表达式；反之则不然：

int arr[scale(2)];//正确：scale(2)是常量表达式
int i = 2;//i不是常量表达式
int a2[scale(i)];//错误：scale(i)不是常量表达式

如上例所示，当我们给scale函数传入一个形如字面值2的常量表达式时，它的返回类型也是常量表达式。此时，编译器用相应的结果值替换对scale函数的调用。

如果我们用一个非常量表达式调用scale函数，比如 int类型的对象i，则返回值是一个非常量表达式。当把scale函数用在需要常量表达式的上下文中时，由编译器负责检查函数的结果是否符合要求。如果结果恰好不是常量表达式，编译器将发出错误信息。

把内联函数和constexpr函数放在头文件内

和其他函数不一样，内联函数和constexpr函数可以在程序中多次定义。毕竟，编译器要想展开函数仅有函数声明是不够的，还需要函数的定义。不过，对于某个给定的内联函数或者constexpr函数来说，它的多个定义必须完全一致。基于这个原因，内联函数和constexpr函数通常定义在头文件中。

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！