C++ const的那些事

---

const和#define的抉择

const常量是编译运行阶段使用，const常量会在内存中分配。而define宏常量是在预处理阶段展开，有多少地方使用，就展开多少次，不会分配内存。const常量有数据类型，而define宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。并且const常量可以限定作用域，而define宏常量都是全局的。const既然有怎么多的好处，而且C++也推荐使用const，我们何乐不为了！

const类型的定义

非指针类型: const type name 或 type const name

//main.cpp# include<iostream>int main(){    const int var_1 = 123;//int类型的常量    double const var_2 = 1.23;//double类型的常量    /*常量类型只能由常量指针指向或常量引用引用*/    const int *var_3 = &var_1;//常量指针    int const *var_4 = &var_1;//常量指针    double const &var_5 = var_2;//常量引用    const double &var_6 = var_2;//常量引用    return 0;}

指针类型:

• 常量指针，即指向常量的指针(一个不能修改其指向对象的指针，可以接受const和非const类型数据)。
• 指针常量，指针类型的产量(一个不能修改其自身的指针，只可以非const类型数据)。

常量指针:const type *name 或 type const *name

//main.cpp# include<iostream>int main(){  const int var_1 = 123;  int var_2 = 456;  const int *var_3 = &var_1;//int const *var_3 = &var_1  var_3 = &var_2;  return 0;}

指针常量:type * const name

//main.cpp#include<iostream>int main(){    int var_1 = 123;    int * const var_2 = &var_1;    return 0;}

引用类型:

常量引用，即指向常量的引用(一个不能修改其指向对象的引用，并且也不能修改其自身的引用，可以接受const和非const类型数据)。

常量引用:const type &name 或 type const &name

//main.cpp# include<iostream>int main(){    const int var_1 = 123;    int var_2 = 456;    const int &var_3 = var_1;//int const &var_3 = var_1;    //var_3=var_2;常量引用不能修自身    return 0;}

const类型与函数

在函数传参时使用引用/指针传参时速度更快(无需进行拷贝)，而使用const引用/指针既可以保证原始数据的安全性(将不能被修改)，又有引用/指针传参的速度。const类型引用/指针的形参可以使得函数传参是可以处理const和非const类型的实参，若不使用const只能处理非const实参。const引用传参时形参与实参不匹配，c++将生成类型正确临时变量，并让参数引用临时变量(c++只有在const引用时才会这么做)。

//main.cpp# include<iostream>int sum_1(int &val_1, int &val_2){    return val_1 + val_2;}int sum_2(const int &val_1, const int &val_2){    return val_1 + val_2;}int sum_3(const double &val_1, const double &val_2){    return val_1 + val_2;}int main(){    int var_1 = 1;    const int var_2 = 1;    //sum_1(var_1, var_2);因为var_2是const int类型，无法被int &接受    sum_2(var_1 , var_2);    sum_3(var_1, var_2);//由于参数类型不一致，sum_3生成正确的临时变量，并将参数引用临时变量    return 0;}

函数的返回值也可用const限定。当函数返回值为const引用/指针类型时，函数的返回值类型就必须要用const类型限定。

//main.cpp# include<iostream>const int & max(const int &val_1, const int &val_2){    if (val_1 >= val_2)    {        return val_1;    }    else    {        return val_2;    }}int main(){    int var_1 = 1;    int var_2 = 2;    std::cout << max(var_1, var_2)<<std::endl;    return 0;    /*    2    */}

const类型与类

在c++中const可以限定类的成员，但由于const类型必须进行初始化，所以在c++中，const类型的类成员必须在类构造之前进行初始化，即在初始化列表进行初始化。

//main.cpp# include<iostream>class C{public:    C():m_var(1){}//使用初始化列表进行初始化    ~C() {}    const int m_var;};int main(){    C obj;}

在c++中const可以限定类的成员函数，即承诺在本函数内部不会修改类内的数据成员，不会调用其它非const 成员函数(非const成员函数可以调用const成员函数)。在分文件定义时需要在声明文件里和定义文件里分别用const限定类成员函数(那么多限定符，就它要声明和定义都限定)。

在c++中const限定的对象，只能调用const成员函数。当成员函数重载时，非const限定的对象，优先调用非const限定的成员函数。

#ifndef C.H#define C_Hclass C{public:    C();    ~C();    void print()const;    void print();    void swap();private:    int m_var_1;    int m_var_2;};#endif

//C.cpp#include "C.h"#include <iostream>C::C(){    m_var_1 = 1;    m_var_2 = 2;}C::~C(){}void C::print(){    std::cout << "print " << m_var_1 << " " << m_var_2  << std::endl;}void C::print()const{    //swap();不能调用非const限定成员函数    //m_var_1=2;不能调用修改类成员    std::cout << "print const " << m_var_1 << " " << m_var_2  << std::endl;}void C::swap(){    int tmp;    tmp = m_var_1;    m_var_1 = m_var_2;    m_var_2 = tmp;}

//main.cpp# include <iostream>#include "C.h"int main(){    C obj_1;    const C obj_2;    obj_1.print();    obj_1.swap();    obj_2.print();    //obj_2.swap();const对象不能调用非const限定的成员函数    return 0;    /*    print 1 2    print const 1 2    */}