const

const与指针

void foo()
{
    char sz[] = "Hello World";
    char *psz = sz;
    char *const cpsz = sz;
    const char *pcsz = sz;
    const char * const cpcsz = sz;

    psz[0] = 'J'; // ok
//  cpsz++;       // error, cpsz is const
//  pcsz[0] = 'K';// error, pcsz[0] is const

    vector vec;
    const vector::iterator cit; // cit is const, like char *const p
    vector::const_iterator itc; // point to const, like const char *p
}

const与返回值

struct Complex
{
    Complex(double a, double b):m_a(a), m_b(b)
    {}
    double m_a;
    double m_b;
};

// 1. 返回类型不能是临时对象的引用
// 2. 返回const对象避免(a*b) = c，(a*b)返回的是const对象，不能赋值
const Complex operator*(const Complex& l, const Complex& r)
{
    return Complex(l.m_a * r.m_a,
                   l.m_b * r.m_b);
}

const与成员函数

class Foo
{
public:
    // f1
    const char& operator[] (const string::size_type pos) const
    {
        // ...
        return m_data[pos];
    }

    // f2
    //char& operator[] (const string::size_type pos)
    //{
    //    // ...
    //    return m_data[pos];
    //}

    // 避免f1和f2代码重复的技术
    char& operator[] (const string::size_type pos)
    {
        // 1. 调用此方法的对象必定是一个none const对象，所以const_cast是安全的
        // 2. 用static_cast把this转成一个const对象，明确调用const版本operator[]，避免递归
        return const_cast(
                static_cast(*this)[pos]);
    }
private:
    static string m_data;
};
string Foo::m_data = "Hello World";

void print_char(const Foo& f)
{
    cout << f[0]; // 调用且只能调用f1，因为f是const对象
}

void set_char(Foo &f)
{
    f[0] = 'K';  // 调用且只能调用f2，因为f2的返回才可被赋值
}

const的bitwise和logical

class Text
{
public:
    // 计算长度的方法，应声明为const
    const string::size_type length() const
    {
        if (!m_bLengthValid)
        {
            // 这里要缓存text的长度，需要将m_length声明为mutable
            m_length = m_text.length();
            m_bLengthValid = true;
        }
        return m_length;
    }

private:
    string m_text;
    // 声明为mutable，即使在const方法内也可以被修改，这就是logical const
    mutable string::size_type m_length;
    mutable bool m_bLengthValid;
};