尽量使用const

尽可能的使用const

const:使用const的好处是指定一种语义上的约束----某种对象不能被修改，而作用于变量上，则告诉编辑器和其他程序员：此变量为常量，不可被修改。

一、const作用在变量上：

看下面的例子：

char *p              = "hello";          // 非const指针,
                                         // 非const数据

const char *p        = "hello";          // 非const指针,
                                         // const数据

char * const p       = "hello";          // const指针,
                                         // 非const数据

const char * const p = "hello";          // const指针,
                                         // const数据

怎样判断是const指针还是const数据？

语法并非看起来那么变化多端。一般来说，你可以在头脑里画一条垂直线穿过指针声明中的星号（*）位置，如果const出现在线的左边，指针指向的数据为常量；如果const出现在线的右边，指针本身为常量；如果const在线的两边都出现，二者都是常量。

在指针所指为常量的情况下，有些程序员喜欢把const放在类型名之前，有些程序员则喜欢把const放在类型名之后、星号之前。所以，下面的函数取的是同种参数类型：

class widget { ... };

void f1(const widget *pw);      // f1取的是指向
                                // widget常量对象的指针

void f2(widget const *pw);      // 同f2

因为两种表示形式在实际代码中都存在，所以要使自己对这两种形式都习惯。

二、const的一些强大的功能基于它在函数声明中的应用。在一个函数声明中，const可以指的是函数的返回值，或某个参数；对于成员函数，还可以指的是整个函数。

让函数返回一个常量值经常可以在不降低安全性和效率的情况下减少用户出错的几率。对返回值使用const有可能提高一个函数的安全性和效率，否则还会出问题。

看下面的例子：

#include <iostream>
using namespace std;

class String
{
public:
	String();
	~String();
	String(const char *value);
	const String & operator=(const String & rhs);
	char & operator[](int position);
	const char & operator[]( int position)const;

private:
	char *data;

};


//Default Constructor 
String::String()
{
	data =  new char[1];
	data = '\0';
}


String::~String()
{
   delete []data;
}

String::String(const char *value)
{
	if(value)
	{
		data = new char[strlen(value) + 1];
		strcpy(data,value);
	}
	else
	{
		data =  new char[1];
		data = '\0';
	}

}

const String & String::operator=(const String &rhs)
{
	if(this == &rhs)
		return *this;
	delete [] data;

	data = new char[sizeof(rhs.data)+1];
	strcpy(data,rhs.data);

	return *this;
}

char & String::operator[](int position)
{
	return data[position];
}

const char & String::operator[]( int position ) const
{
   return data[position];
}


int main()
{
	string s1 = "hello";
	cout << s1[0] << endl;                  // 调用非const
	s1[0] = 'w';
	cout << s1[0] << endl;

	const string s2 = "world";
	cout << s2[0] << endl;                  // 调用const

	//s2[0] = 'h';

	return 0;
}

有两个重载操作函数：
char & String::operator[](int position)
{
return data[position];
}

const char & String::operator[]( int position ) const
{
   return data[position];
}

第一个返回类型是char&的引用，第二个返回类型是const的char引用。

问题1:为何第一个返回类型是char&的引用，而不是char

若是char，那么语句：s1[0] = 'w';就不能通过编译，s1[0] =返回一个char类型，没有对一个返回类型为char的赋值，这是不允许的。

问题2：返回类型为const，有何作用？

//s2[0] = 'h';这个语句不能通过编译，是因为要赋值给一个const量，编辑器是不允许的，s2[0] ='h'等价为const data[0] = 'h';

由此看出让函数返回一个常量值经常可以在不降低安全性和效率的情况下减少用户出错的几率。

三、成员函数为const的确切含义是什么？？

bitwise constness的坚持者认为，当且仅当成员函数不修改对象的任何数据成员（静态数据成员除外）时，即不修改对象中任何一个比特(bit)时，这个成员函数才是const的。

但是不幸的是很多不遵守bitwise constness定义的成员函数可以修改数据成员，特别是，一个“修改了指针所指向的数据”的成员函数，其行为显然违反了bitwise constness定义，但如果对象中仅包含这个指针，这个函数也是bitwise const的，编译时会通过。这就和我们的直觉有差异：

上面的例子改一改：

operator char *() const { return data;}
const string s = "hello";      // 声明常量对象

char *nasty = s;               // 调用 operator char*() const

*nasty = 'm';                  // 修改s.data[0]

cout << s;                     // 输出"mello"

其输出结果为：mello


四、如何是const成员函数也可以修改数据成员

这就是mutate 关键词的引入。

解决方案很简单：利用c++标准组织针对这类情况专门提供的有关const问题的另一个可选方案。此方案使用了关键字mutable，当对非静态数据成员运用mutable时，这些成员的“bitwise constness”限制就被解除：

class string {
public:

  ...    // same as above

private:
  char *data;

  mutable size_t datalength;      // 这些数据成员现在
                                  // 为mutable；他们可以在
  mutable bool lengthisvalid;     // 任何地方被修改，即使
                                  // 在const成员函数里
}; 

size_t string::length() const
{
  if (!lengthisvalid) {
    datalength = strlen(data);    // 现在合法
    lengthisvalid = true;         // 同样合法
  }

  return datalength;
}