const用法

const限定符#

1
const int a = 10;

1
int const a = 10;

1
//可以用一个变量初始化常量
2
int i1 = 10;
3
const int i2 = i1;
4
//也可以将一个常量赋值给一个变量
5
int i3 = i2;

1
//错误用法，const变量必须初始化
2
//const int i4;

指针和const#

1
//PI 是一个常量,它的值不能改变
2
const double PI = 3.14;
3
//错误，ptr是一个普通指针
4
//double * ptr = Π
5
//正确,cptr可以指向一个双精度常量
6
const double *cptr = Π
7
//错误，不能给*ptr赋值
8
//*cptr = 3.14;

1
//可以用指向常量的指针指向一个非常量
2
int i10 = 2048;
3
//ptr指向i10
4
int *cptr2 = &i10;

1
int errNumb = 0;
2
//curErr是一个常量指针，指向errNumb
3
int * const curErr = &errNumb;
4
const double pi2 = 3.14;
5
//pip 是一个指向常量对象的常量指针
6
const double *const pip = &pi2;

1
//错误，pip是一个指向常量的指针
2
//*pip = 2.72;
3
//可以修改常量指针指向的内容
4
*curErr = 1024;
5
//可以修改常量指针指向的地址
6
//curErr = &i10;

顶层const#

指针本身是一个对象，它又可以指向另外一个对象。因此，指针本身是不是常量以及指针所指的是不是一个常量就是两个相互独立的问题

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

1
int i = 0;
2
//不能改变p1的值，这是一个顶层const
3
int * const pi = &i;
4
//不能改变ci的值，这是一个顶层const
5
const int ci  = 42;
6
//允许改变p2的值，这是一个底层const
7
const int *  p2 = &ci;
8
//靠右边的const是顶层const，靠左边的const是底层const
9
const int * const p3 = p2;
10
//用于声明引用的const都是底层const
11
const int &r = ci;

底层const的限制却不能忽视。当执行对象的拷贝操作时，拷入和拷出的对象必须具有相同的底层const资格，或者两个对象的数据类型必须能够转换

1
//指针赋值要注意关注底层const
2
//p2拥有底层const,p4无底层const，所以无法赋值
3
//int * p4 = p2;

constexpr和常量表达式#

常量表达式（const expression）是指值不会改变并且在编译过程就能得到计算结果的表达式。显然，字面值属于常量表达式，用常量表达式初始化的const对象也是常量表达式。后面将会提到，C++语言中有几种情况下是要用到常量表达式的。

我们先在global.h中声明一个全局函数返回固定大小

1
extern int GetSize();

在global.cpp中实现

1
int GetSize(){
2
    return 20;
3
}

然后我们用const定义一些常量表达式

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

1
{
2
    //max_files是一个常量表达式
3
    const int max_files = 20;
4
    //limit是一个常量表达式
5
    const int limit = max_files + 10;
6
    //staff_size不是常量表达式,无const声明
7
    int staff_size = 20;
8
    //sz不是常量表达式,运行时计算才得知
9
    const int sz = GetSize();
10
}

尽管staff_size的初始值是个字面值常量，但由于它的数据类型只是一个普通int而非const int，所以它不属于常量表达式。

另一方面，尽管sz本身是一个常量，但它的具体值直到运行时才能获取到，所以也不是常量表达式。

在一个复杂系统中，很难（几乎肯定不能）分辨一个初始值到底是不是常量表达式。

当然可以定义一个const变量并把它的初始值设为我们认为的某个常量表达式，但在实际使用时，尽管要求如此却常常发现初始值并非常量表达式的情况。

C++11新标准

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

1
//20是一个常量表达式
2
constexpr int mf = 20;
3
//mf+1是一个常量表达式
4
constexpr int limit = mf + 10;
5
//错误，GetSize()不是一个常量表达式，需要运行才能返回
6
//constexpr int sz = GetSize();

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

1
inline constexpr int GetSizeConst() {
2
    return 1;
3
}

为了避免在多个源文件中包含同一个头文件而导致的多重定义错误，可以将 constexpr 函数声明为 inline。

inline 关键字允许在多个翻译单元中定义同一个函数，而不会引起链接错误。

接下来在定义一个constexpr变量就行了

1
constexpr int sz = GetSizeConst();

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

1
//p是一个指向整形常量的指针
2
const int * p = nullptr;
3
//q是一个指向整数的常量指针
4
constexpr int *q = nullptr;

一个constexpr指针的初始值必须是nullptr或者0，或者是存储于某个固定地址中的对象。

函数体内定义的变量一般来说并非存放在固定地址中，因此constexpr指针不能指向这样的变量。

定义于所有函数体之外的对象其地址固定不变，能用来初始化constexpr指针

global_i是一个全局变量

1
//constexpr指针只能绑定固定地址
2
//constexpr int *p = &mvalue;
3
constexpr int *p = nullptr;
4
//可以绑定全局变量，全局变量地址固定
5
constexpr  int *cp = &global_i;

可以修改constexpr指向的内容

1
constexpr int *p = &global_i;
2
//修改p指向的内容数据
3
*p = 1024;