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熟悉之后在聊吧。