Effective C++ 第三条，尽可能使用const

const可以修饰指针，也可以修饰指针所指物 ， 指针用const修饰时，指针不能改变

p3++

非法，指针所指物用const修饰时指针所指物不能改变

*p1 = 1

非法。

char str[] = "ni hao";
char *p = str;    // 非常量指针，非常量数据
const char *p1 = str; //非常量指针， 常量数据
char const *p2 = str; // 等于上一个
char *const p3 = str; // 常量指针， 非常量数据
const char* const p4 = str; //常量指针，常量数据

STL迭代器就像指针T* 一样，声明const it就像声明指针为常量一样，T* const,所以it没法自增，改变所指物可以。

std::vector<int> v(10,7);
const std::vector<int>::iterator it = v.begin();
*it = 10;  //通过编译
++it;      //非法

const可以修饰函数返回值，函数参数和（成员函数）函数自身。

class Rational
{...};
const Rational operator* (const Rational& num1, const Rational& num2);

修饰成员函数时如果只是参数的常量性不同看可以被重载

class Text {
public:
Text(const string &str)
:text ( str)
{}
const char& operator [](size_t size)const
{
return text[size];
}

char& operator [](size_t size)
{
return text[size];
}

private:
std::string text;
};

int main()
{
Text t("abcd");
const Text ct("abcd");
return 0;
}

mutable(可变的)释放掉non-static成员变量的约束性，如果你想改变const成员函数的一部分

#include <iostream>
using namespace std;
#include <string>

class Text {
public:
Text(const string &str, size_t len = 0)
:text ( str)
,textlength(len)
{}

const char& textc()const
{
textlength > text.length();
textlength = 0;   //这里可以改变
return text[textlength];
}

private:
std::string text;
mutable size_t textlength;  //可变的
};

int main()
{
const Text ct("abcd",10);
cout << ct.textc() << endl;
system("pause");
return 0;
}

如果存在大量的no_const和const需要两个函数很造成很多的代码重复。用const函数调用非const函数是错误的,因为要通过编译需要将*this的常量性解放。 反向调用是安全的。

#include <iostream>
using namespace std;
#include <string>

class Text {
public:
Text(const string &str)
:text(str)
{}
const char& operator [](size_t size)const
{
return text[size];
}

char& operator [](size_t size)
{
return const_cast<char&>(static_cast<const Text&>(*this)[size]) ;
}

private:
std::string text;
};

int main()
{
Text t("abcd");
const Text ct("abcd");
return 0;
}