条款3：尽可能使用const

const与指针结合
const与指针结合有两种情况：一个常指针：指向不能变；指向常对象的指针：可以指向其他的变量，但这些变量必须是const类型。怎么区别它们呢？const在*左边，则是一个指向常对象的指针，而const在*的右边，则是指针的指向不能变。举个例子：

int a = 10;
int b = 5;
const int *pa = &a;
//(*pa) = 10;	指针指向的对象是常量，不能通过指针修改对象
int * const pb = &b;
//pb = &a;		常指针，不能修改指向

const与迭代器结合

以此类推，由指针实现的迭代器也有两种类型：

vector<int> ivec;
for(int i = 0; i < 3;++i)
ivec.push_back(i);
vector<int>::const_iterator citer = ivec.begin();
//*citer = 10;		不能通过const_iterator修改指向的对象
++citer;				//可以修改指向
const vector<int>::iterator iter = ivec.begin();
*iter = 10;
//++iter;			不能改变指向

const与函数的返回值，参数，函数自身结合与返回值结合：

为什么要让一个函数返回一个const值呢？举一个例子可以说明，假如我们定义了一个类，并重载了乘法操作符*，和赋值操作符=。那么对于这个类的3个对象a，b，c，下面的操作就变得合法了：(a*b) = c;但是如果乘法操作的返回值是const类型的，那么(a*b) = c就不合法了。

很多人都会对这个小的修改不屑一顾，因为正常人都不会这么写程序，但是很多时候，我们都会将if((a*b) == c)写成(a*b) = c！这时候，这个操作就派上了用场，编译器会直接检查出这个操作的错误。

const与类的成员函数结合，构成const成员函数。const成员函数不能改变对象的值。如果的确是这样，那么尽量将函数写为const函数，因为：
1.它使类的接口更加容易理解，让人们一看就知道哪个函数是改变对象内容的，哪个不是：

class Test
{
private:
int val;

public:
Test(int i = 10):val(i){}
int getVal()const;
void setVal(int);
};
值得注意的是，如果声明为const函数，那么在定义时，也要加上const：

#include "item2.h"

int Test::getVal()const
{
return val;
}

void Test::setVal(int i)
{
val = i;
}

2.它们是得“操作const对象成为可能”。为什么要操作const对象呢？说来话长。我们先看一个例子：

class Person
{
public:
Person(string nm = "mao",string add = "china"):name(nm),address(add){}
private:
string name;
string address;
};

class Student:public Person
{
public:
Student(int i = 0):schoolNumber(i){}
bool is_same(Student);
private:
int schoolNumber;

};

其中，is_same函数完成比较两个学生是否是同一个人的操作：

bool Student::is_same(Student s)
{
return schoolNumber == s.schoolNumber;
}

但是，这个函数的效率很低，原因在于：这个函数是按值传递的。这意味着会有一个Student类型的实参复制给s。这就会调用s的构造函数，s的构造函数会调用Person的构造函数，而Person的构造函数会调用那两个string对象的构造函数。有没有办法提高他的效率呢？有的，就是pass by refrence to const：bool is_same(Student &)const;具体来说，因为原函数传递的是值，并不会修改对象的数据成员，所以可以把它替换为使用const函数；其次，传递引用时，并不会发生对象的复制，也就没有构造函数，析构函数的调用了。

扯远了一点，我们再回到问题的开始：因为pass by refrence to const是更有效的作法，所以我们会经常这样做，但是这样做的前提，就是需要把函数定义为const函数。

const函数还有一点需要注意的是，他可以与非const函数发生重载：

class TextBook
{
public:
TextBook(string bookNumber = "newbook",string content = "this is a book"):isbn(bookNumber),test(content){}
char &operator[](size_t pos){return test[pos];}
const char &operator[](size_t pos)const{return test[pos];}
private:
string isbn;
string test;
};

那么

TextBook book("effective c++","item3");
cout<<book[1]<<endl;		//调用非const操作符
const TextBook book_read_only;
cout<<book_read_only[1]<<endl;//调用const操作符[]
//book_read_only[1] = "aaa";	//错误，无法修改

关于const函数，还有一个值得思辨的地方，就是假如这个传递给函数的参数是一个指针，那么const函数的确不会修改这个指针，但是我们可以轻易地通过指针来修改这个对象的其他内容。此时，最好不要把它声明为const函数。假如我们的类需要跟C API通信，那么就得使用char*来存储书籍内容了：

class TextBook
{
public:
TextBook(char* content = "aaa")
{
int i = 0;
while(content[i] != NULL)
{

++i;
}
ptest = (char*)malloc(sizeof(char) * i);
int j = 0;
for( j = 0 ; j < i;++j)
ptest[j] = content[j];
ptest[j] = NULL;
}
char& operator[](size_t pos)const{return ptest[pos];}
private:
char* ptest;
};

此时虽然将下标操作符声明为const函数，但是编译器依然允许我们改动的内容，反正我们并没有改变指针的指向：

TextBook book("item3");
cout<<book[0]<<endl;
book[0] = 'I';
cout<<book[0]<<endl;

这样的const函数声明就会遭人误解，还是不要声明为好。

但有的时候，我们又希望某些成员变量在const函数中也能被改动，怎么办呢？就是使用mutable关键字来声明这个变量：

int getRemainingNumber()const{return total--;}
private:
char* ptest;
mutable int total;

最后，我们还要说一个问题。就是如果一个函数的const版本和非const版本的功能类似，那么能不能通过一个调用另外一个呢？答案是可以的：我们可以在非const版本中调用const版本，而不要（而不是不能，无语ing）在const版本中调用非const版本。后者是显然的，const函数既然承诺不修改数据成员，那么调用可以修改数据成员的非const版本就显得名不副实。前者需要仔细的推敲：

const char& operator[](size_t pos)const{return content[pos];}
char& operator[](size_t pos)
{
return const_cast<char&>(static_cast<const TextBook&>(*this)[pos]);
//首先，将*this由原来的TextBook&转化为const TextBook&
//然后，调用const char& operator[](size_t pos)const，如果没有第一部，则会自己递归调用自己！
//最后，使用const_cast<char&>去掉const类型
}

这一小节的内容差不多就是这么多了，总的来说：

1.能用const的地方尽量用，这样编译器会帮你检查很多错误。

2.如果如果一个函数有const版本和非const版本，那么我们可以使用非const版本来调用const版本，来减少代码的工作量。