[c++]-constexpr与const区别

1.const部分

const 是constant的缩写，本意是不变的，不易改变的意思。

const 在C++中是用来修饰内置类型变量，自定义对象，成员函数，返回值，函数参数。

1.1const修饰普通类型的变量

const int  a = 7; 
int  b = a; //it's right
a = 8;       // it's wrong,

a被定义为一个常量，并且可以将a赋值给b，但是不能给a再次赋值。对一个常量赋值是违法的事情，因为a被编译器认为是一个常量，其值不允许修改。

如下例子

#include<iostream>
using namespace std;
int main(void)
{
    const int  a = 7;
    int  *p = (int*)&a; //这里做了一次强转，将a的地址转为指向int型变量的指针
    *p = 8;
    cout<<a;
    system("pause");
    return 0;
}

对于const变量a，我们取变量的地址并转换赋值给 指向int的指针，然后利用*p = 8;重新对变量a地址内的值赋值，然后输出查看a的值。

从下面的调试窗口看到a的值被改变为8，但是输出的结果仍然是7。


从结果中我们可以看到，编译器然后认为a的值为一开始定义的7，所以对const a的操作就会产生上面的情况。所以千万不要轻易对const变量设法赋值，这会产生意想不到的行为。

如果不想让编译器察觉到上面到对const的操作，我们可以在const前面加上volatile关键字

Volatile关键字跟const对应相反，是易变的，容易改变的意思。所以不会被编译器优化，编译器也就不会改变对a变量的操作。

#include<iostream>
using namespace std;
int main(void)
{
    volatile const int  a = 7;
    int  *p = (int*)&a;
    *p = 8;
    cout<<a;
    system("pause");
    return 0;
}

1.2const 修饰指针变量

const 修饰指针变量有以下三种情况。

• A:const 修饰指针指向的内容，则内容为不可变量。

• B:const 修饰指针，则指针为不可变量。

• C:const 修饰指针和指针指向的内容，则指针和指针指向的内容都为不可变量。

对于A

const int *p = 8; 

则指针指向的内容8不可改变。简称左定值，因为const位于*号的左边。

对于B

int a = 8;
int* const p = &a;
*p = 9; //it’s right  这里改变的是指向的内容
int  b = 7;
p = &b; //it’s wrong  这里则改变了p指向的地址

对于const指针p其指向的内存地址不能够被改变，但其内容可以改变。简称，右定向。因为const位于*号的右边。

对于C

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

这时，const p的指向的内容和指向的内存地址都已固定，不可改变。

“左定值，右定向，const修饰不变量”。

1.3const参数传递和函数返回值

对于const修饰函数参数可以分为三种情况。

• A：值传递的const修饰传递，一般这种情况不需要const修饰，因为函数会自动产生临时变量复制实参值。

#include<iostream>
using namespace std;
void Cpf(const int a)
{
    cout<<a<<endl;
    // ++a;  it's wrong, a can't is changed
}
int main(void)
{
    Cpf(8);
    system("pause");
    return 0;
}

• B：当const参数为指针时，可以防止指针被意外篡改。

#include<iostream>
using namespace std;
void Cpf(int *const a)
{
    cout<<*a<<" ";
    *a = 9;
}
int main(void)
{
    int a = 8;
    Cpf(&a);
    cout<<a; // a is 9
    system("pause");
    return 0;
}

• C：自定义类型的参数传递，需要临时对象复制参数，对于临时对象的构造，需要调用构造函数，比较浪费时间，因此我们采取const外加引用传递的方法。

并且对于一般的int ，double等内置类型，我们不采用引用的传递方式。

#include<iostream>
using namespace std;
class Test
{
public:
    Test(){}
    Test(int _m):_cm(_m){}
    int get_cm()const
    {
       return _cm;
    }
private:
    int _cm;
};

void Cmf(const Test& _tt)
{
    cout<<_tt.get_cm();
}
int main(void)
{
    Test t(8);
    Cmf(t);
    system("pause");
    return 0;

}

对于const修饰函数的返回值

Const修饰返回值分三种情况。

• A：const修饰内置类型的返回值，修饰与不修饰返回值作用一样。
• B:const修饰自定义类型的作为返回值，此时返回的值不能作为左值使用，既不能被赋值，也不能被修改。
• C: const修饰返回的指针或者引用，是否返回一个指向const的指针，取决于我们想让用户干什么。

1.4const修饰类成员函数

const 修饰类成员函数，其目的是防止成员函数修改被调用对象的值，如果我们不想修改一个调用对象的值，所有的成员函数都应当声明为const成员函数。

注意：const关键字不能与static关键字同时使用，因为static关键字修饰静态成员函数，静态成员函数不含有this指针，即不能实例化，const成员函数必须具体到某一实例。

下面的get_cm()const;函数用到了const成员函数

#include<iostream>
using namespace std;
class Test
{
public:
    Test(){}
    Test(int _m):_cm(_m){}
    int get_cm()const
    {
       return _cm;
    }
private:
    int _cm;
};
void Cmf(const Test& _tt)
{
    cout<<_tt.get_cm();
}
int main(void)
{
    Test t(8);
    Cmf(t);
    system("pause");
    return 0;
}

如果get_cm()去掉const修饰，则Cmf传递的const _tt即使没有改变对象的值，编译器也认为函数会改变对象的值，所以我们尽量按照要求将所有的不需要改变对象内容的函数都作为const成员函数。

如果有个成员函数想修改对象中的某一个成员怎么办？这时我们可以使用mutable关键字修饰这个成员，mutable的意思也是易变的，容易改变的意思，被mutable关键字修饰的成员可以处于不断变化中，如下面的例子。

#include<iostream>
using namespace std;
class Test
{
public:
   Test(int _m,int _t):_cm(_m),_ct(_t){}
   void Kf()const
   {
       ++_cm; //it's wrong
       ++_ct; //it's right
   }
private:
   int _cm;
   mutable int _ct;
};

int main(void)
{
   Test t(8,7);
   return 0;
}

这里我们在Kf()const中通过++_ct;修改_ct的值，但是通过++_cm修改_cm则会报错。因为++_cm没有用mutable修饰。

---

2.constexpr部分

2.1常量表达式

常量表达式是指值不会改变并且在编译过程中就能得到计算结果的表达式。

• 编译过程中得到计算结果。

• 字面值属于常量表达式，用常量表达式初始化的const对象也是常量表达式。

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

注意：对于这条语句：const int sz = get_size();，sz本身是常量，但它的具体值直到运行时才能获得，不是常量表达式。

#include<iostream>

using namespace std;

int main(int argc, char* argv[]) {
	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本身是常量，但它的具体值直到运行时才能获得，不是常量表达式
}

2.2constexpr变量

• 在一个复杂的系统中，很难分辨一个初始值到底是不是常量表达式。当然可以定义一个const变量并把它的初始值设为我们认为的某个常量表达式，但在实际使用时，尽管要求如此却常常发现初始值并非常量表达式的情况（例如上述的const int sz = get_size(); 语句）。

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

#include<iostream>

using namespace std;

int main(int argc, char* argv[]) {
	constexpr int max_files = 20;          //20是常量表达式
	constexpr int limit = max_files + 1;   //max_files + 1是常量表达式
	constexpr int sz = size();         //重要！！！只有当size是一个constexpr函数时，才是一条正确的声明语句
}

尽管不能使用普通函数作为constexpr变量的初始值，但可以通过constexpr函数（编译时就可以计算其结果）初始化constexpr变量。

2.3constexpr函数

constexpr函数是指用于常量表达式的函数。

遵循以下规定：

• （1）函数的返回类型以及所有形参的类型都得是字面值类型；
• （2）函数体中必须只有一条return语句。

#include<iostream>

using namespace std;

constexpr int new_sz() {
	return 42;
}

int main(int argc, char* argv[]) {
	constexpr int foo = new_sz();
	cout << foo << endl;  //42
	getchar();
	return 0;
}

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

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

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

constexpr int size() {  //返回值类型为字面值类型
	; //空语句
	using In = int; //using声明
	typedef int INT; //类型别名
	return 10;
}

我们允许constexpr函数的返回值并非一个常量。当scale的实参是常量表达式，它的返回值也是常量表达式，反之则不然：

#include<iostream>

using namespace std;

constexpr int size() {
	;
	using namespace std;
	typedef int INT;
	return 10;
}

constexpr int new_sz() {
	return 42;
}

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

int main(int argc, char* argv[]) {
	int arr[scale(2)];  //正确
	//int i = 2;
	//int arr2[scale(i)];  //错误：scale(i)不是常量表达式
	const int j = 2;
	int arr3[scale(j)];  //正确
	getchar();
	return 0;
}

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

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

2.4指针和constexpr

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

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

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