条款03：尽肯使用const

定义常量

• define 是一个Compile-Time的概念，它的生命周期止于编译器期，它存在与程序的代码段，在实际程序中它只是一个常数、一个命令中的参数、并没有实际的存在
• const常量存在于程序的数据段，并在堆栈分配了空间。const常量是一个Run-Time的概念，它在程序中确确实实地存在并可以被调用、传递。const常量有数据类型，而宏常量没有数据类型。编译器可以对const常量进行类型安全检查

const int val = 5;
const char* const p = "hello";
const std::string str{ "world" };

修饰指针变量

当const出现在星号左边，表示被指物是常量；如果出现在星号右边，表示指针自身是常量；如果出现在星号两边，表示被指物和指针两者都是常量

const char * p;(此处可以不初始化) p指向的内容是常量
char *const p; p本身是常量
const char * const p; p和p指向的内容都是常量

修饰引用

int num1 = 8;
const int & num2 = num1;        //常引用，不能通过引用去修改被引用的指（引用必须初始化）
int & const num3 = num1;        //error
const int & const num4 = num1;  //error

修饰函数

修饰函数参数

如果不需要改动参数或local对象，尽量加上const:

• 防止创建副本，减少内存开销
• 防止对引用参数进行修改

void func(const std::string & str);

修饰函数返回值

令函数返回一个常量指，往往可以降低因客户错误而造成的意外，而不至于放弃安全性和高效性

const int func(void);

在类中的使用const

修饰成员变量

• 常成员变量，通过构造函数对其初始化，且只能通过初始化列表的方式初始化
• 一经初始化就不可改变

class A{
public:
    /* A(int a, std::string str){
        m_a = a;
        m_name = str;
    } */

    A(int a, std::string str):m_a(a),m_name(str)
    {
    }

public:
    const int m_a;
    const std::string & m_name;
};

修饰成员函数

const修饰成员函数，本质修饰的是this指针；

• 使class的接口比较容易被理解；清楚的知道哪个函数可以改动对象内容而哪个函数不行
• 使操作const对象成为可能
• 两个成员函数如果只是常量性不同，可以被重载

class TextBlock{
public:
    const char& operator[](std::size_t position)const
    {
        return text[position];
    }

    char& operator[](std::size_t position)
    {
        return
            const_cast<char&>(                                  //将op[]的返回值移除const
                static_cast<const TextBlock&>(*this)[position]  //为*this加上const,调用[]
            );
    }       

private:
    std::string text;
};

修饰对象

常对象只能调用常成员函数；普通对象既可以调用常成员函数也可以调用普通成员函数

class A{
public:
    /* A(int a, std::string str){
        m_a = a;
        m_name = str;
    } */

    A(int a, std::string str):m_a(a),m_name(str)
    {
    }

    void get()const
    {
        std::cout << "call const A& A::get()const" << std::endl;
        std::cout << this->m_a << ' ' << this->m_name << ' ' << std::endl;
    }

    void get()
    {
        std::cout << "call A& A::get()" << std::endl;
        std::cout << this->m_a << ' ' << this->m_name << ' ' << std::endl;
        // return static_cast<const A&>(*this).get();
    }

public:
    const int m_a;
    const std::string & m_name;
};

void test()
{
    A a(8,"hello");
    a.get();

    const A ca(9, "world");
    ca.get();
}

 

• 将某些东西声明为const可帮助编译器侦测出错误用法。const可被施加于任何作用域内的对象、函数参数、函数返回类、成员函数本体
• 编译器强制实施bitwise constness,但你编写程序是应该使用“概念上的常量性”（conceptual constness)
• 当const 和 non-const成员函数有着实质等价的实现时，令non-const版本调用const可避免代码重复