c++ const使用小结

本文主要是对 《Effective C++》中条款03的总结，如果你有这本书，可以去回忆以下有关const的用法的内容，然后不去看下文。

1. const 与指针

const到底修饰的是指针还是指针所指的对象，可以这样判断：

const出现在星号(*)左边，表示指针所值对象是常量；

const出现在星号(*)右边，表示指针自身是常量；

const出现在星号(*)两边，表示被指物和指针都是常量。

例如：char str[] = "Hello";
char* p = str; //non-const pointer,non-const data
const char* p = str; //non-const pointer,const data
char* const p = str; //const pointer,non-const data
const char* const p = str; //const pointer, const data

以下两种写法等价：

const MyClass *pm;

MyClass cosnt *pm;

2. const 迭代器与const_iterator

声明迭代器为const就像声明指针为const一样，这个迭代器不得指向不同的东西，但是它所指向的内容可以改变。如果不希望迭代器的东西被改动，可以使用const_iterator。

下面是一个完整的例子：

#include <iostream>
#include <vector>

using namespace std;

int main()
{
vector<int> vec;
for(int i = 1; i != 10; ++i)
{
vec.push_back((i+i*2)*3);
}

vector<int>::iterator it;
for(it = vec.begin(); it != vec.end(); ++it)
{
cout << *it << ',';
}
cout << endl;

/*
const vector<int>::iterator iter;

for(iter = vec.begin(); iter != vec.end(); ++iter) //出错！ iter是const，不能改变iter 的值，但是可以改变*iter
{
cout << *iter << ',';
}
cout << endl;

iter = vec.begin(); //错误，不能给iter赋值，只能在初始化定义时赋值
*/
const vector<int>::iterator iter = vec.begin();
*iter = 7777; //可以改变iter所指对象的内容
cout << endl;

vector<int>::const_iterator cIter;
for(cIter = vec.begin(); cIter != vec.end(); ++cIter)
{
cout << *cIter << ',';
}
cout << endl;
//*cIter = 888888; //错误！cIter所指对象的值不能改变

}


3. 常成员函数

const 成员函数承诺绝对不改变其对象的逻辑状态，即不会改变数据成员，也不会调用非 const成员函数，除非成员被mutable修饰。

#include <iostream>
using namespace std;

class TextBook
{
public:
TextBook();
~TextBook();
TextBook(const std::string& rhs);
TextBook(const TextBook& rhs);
TextBook& operator= (const TextBook& rhs);

const char& operator[] (std::size_t position) const; // for const 对象
const char& operator[] (std::size_t position); // for non-const 对象

void print(const TextBook& ctb) const;
private:
std::string text;
};

TextBook::TextBook()
{
text = "";
}
TextBook::~TextBook()
{

}

TextBook::TextBook(const std::string& rhs)
{
text = rhs;
}

TextBook::TextBook(const TextBook& rhs)
{
text = rhs.text;
}

TextBook& TextBook::operator= (const TextBook& rhs)
{
text = rhs.text;
return *this;
}

const char& TextBook::operator[](std::size_t position) const
{
cout << "const member function called..." << endl;
//text[position] = 'x'; //出错！！常成员函数不能改变成员变量
return text[position];
}

const char& TextBook::operator[](std::size_t position)
{
cout << "non-const member function called..." << endl;
text[position] = 'x'; // 可以
return text[position];
}

void TextBook::print(const TextBook& ctb) const
{
cout << ctb.text << endl;
cout << ctb[0] << endl; //因为ctb是不可改变的，所以必须有常成员函数被调用，如果类没有提供，编译会出错
TextBook tb = ctb;
cout << tb[0] << endl;
}

int main()
{
TextBook tb("Hello");
//tb = "Hello";

tb.print(tb);
cout << tb[0] << endl;
}

程序运行结果：
Hello
const member function called...
H
non-const member function called...
x
non-const member function called...
x

当const和 non-const成员函数有着实质等价的实现时，令non-const版本调用const版本可避免代码重复。但是这一点我还是不太会用，待以后对cast熟悉之后在聊吧。