条款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可避免代码重复

巴特西