Effective C++笔记之三：尽可能使用const

       关键字const多才多艺。你可以用它在classes外部修饰global或namespace(见Effective C++笔记之二) 作用域中的常量，或修饰文件、函数、或区块作用域(block scope)中被声明为static的对象。你也可以用它修饰classes内部的static和non-static成员变量。面对指针，你也可以指出指针自身、指针所指物，或两者都(或都不)是const：

char greeting[]="Hello";
char* p1=greeting;      // non-const pointer,non-const data
const char* p2=greeting;// non-const pointer,const data
char const* p3=greeting;// 和上一行意义相同
char* const p4=greeting;// const pointer,non-const data
const char* const p5 =greeting;// const pointer,const data

一.const作用于迭代器

       STL选代器系以指针为根据塑模出来，所以迭代器的作用就像个T*指针。声明选代器为const就像声明指针为const一样(即声明一个T* const 指针) ，表示这个迭代器不得指向不同的东西，但它所指的东西的值是可以改动的。如果你希望迭代器所指的东西不可被改动(即希望STL模拟一个const T* 指针) ，你需要

的是const_iterator：

std::vector<int> vec;
.....
const std::vector<int>::iterator iter = vec.begin( );
*iter = 10;// OK
++iter;// error
std::vector<int>::const_iterator cIter = vec.begin( );
*cIter = 10;// error
++cIter;// ok

二.const作用于自定义类型的对象

       在定义对象时指定对象为常对象。常对象中的数据成员为常变量，例如：

#include <iostream>
using namespace std;

class Time
{
public:
void printf() const
{
//h = 10;//error C3490: 由于正在通过常量对象访问“h”，因此无法对其进行修改
m = 10;// ok
cout << "Hour:" << h << "Minute:" << m << "Second:" << s << endl;
}

void show()// 不会导致编译错误
{
h = 10;
}
private:
int h;
mutable int m;
int s;
};

int main()
{
const Time t;
t.printf();
system("pause");
return 0;
}

       

       常对象t中的数据成员虽然未显示定义为const数据成员，但它们都是常变量，无法修改它们的值。

       常成员函数printf可以访问常对象中的数据成员，但是不允许修改常对象中的数据成员，除非该数据成员被声明为mutable。

       普通成员函数show虽然不会导致编译错误，但是无法被常对象调用，因为常对象、指向常对象的指针或引用只能用于调用其const型成员函数，而不能调用其非const型的成员函数。
三.const作用于函数
1.令函数返回一个常量值

       这样做往往可以降低因客户错误而造成的意外，而又不至于放弃安全性和高效性，例如，考虑有理数（rational numbers）的operator*声明：

class Rational{ ... };
const Rational operator* (const Rational& lhs, const Rational& rhs);

       这个声明能很好的杜绝由于笔误而导致的如下操作：

Rational a,b,c;
if(a * b = c)
{
......
}

       如果a和b都是内置类型，这样的代码直截了当就是不合法。而一个"良好的用户自定义类型"的特征是它们避免无端地与内置类型不兼容。
2.const参数

       至于const参数，没有什么特别新颖的观念，它们不过就像local const对象一样，你应该在必要使用它们的时候使用它们。除非你有需要改动参数或local对象，否则请将它们声明为const。只不过多打6个字符，却可以省下恼人的错误，像是"想要键入'=='却意外键成'=的错误，一如稍早所述。
四.const数据成员
       常数据成员的值是不能改变的，且必须初始化，因为常数据成员是不能被赋值的，关于初始化，详见：Effective C++笔记之一：声明、定义、初始化与赋值

#include <iostream>
using namespace std;

class Time
{
public:
void printf() const
{
//h = 10;//error C3490: 由于正在通过常量对象访问“h”，因此无法对其进行修改
m = 10;
cout << "Hour:" << h << "Minute:" << m << "Second:" << s << endl;
}

//void show()// C2166: 左值指定const对象
//{
//	h = 10;
//}
private:
//const int h;// 报错，没有初始化
const int  h = 10;// 初始化
mutable int m;
const int s = 10;// 初始化
};

int main()
{
const Time t;
t.printf();
system("pause");
return 0;
}

      

       对比“二.const作用于自定义类型的对象”小节，可看出const对象中const数据成员和非const数据成员的区别。

五.const成员函数

       常成员函数只能引用本类中的数据成员（const和非const），而不能修改他们。

       const是函数类型的一部分，在声明函数和定义函数时都要有const关键字，在调用时不必加const。const员函数可以引用const数据成员，也可以引用非const数据成员。const数据成员可以被const成员函数引用，也可以被非const数据成员函数引用，但是不能被修改。

需要注意的是：

1.不要误认为常对象中的成员函数都是常成员函数。常对象只能保证所有的数据成员的值不被修改。如果在对象中的成员函数为加const声明，编译系统把它作为非const成员函数处理。

2.两个成员函数如果只是常量性(constness)不同，可以被重载。举个例子

#include <iostream>
using namespace std;

class TextBlock
{
public:
TextBlock::TextBlock(string str) :test(str)
{

}
const char & operator[](size_t position) const
{
return test[position];
}
char & operator[](size_t position)
{
return test[position];
}
private:
string test;
};

int main()
{
TextBlock tb("Hello");
cout << tb[0] << endl;
const TextBlock ctb("World");
cout << ctb[0] << endl;

system("pause");
return 0;
}

3.常成员函数不能调用另一个非const成员函数。但是非const成员函数可以调用const成员函数。举个例子：

在上述例子中，重载的两个操作符函数体内的代码量小，感觉不到有什么不妥。但是如果代码量大的话，可以让非const operator[]调用其const兄弟来避免代码重复。

#include <iostream>
using namespace std;

class TextBlock
{
public:
TextBlock::TextBlock(string str) :test(str)
{

}
const char & operator[](size_t position) const
{
return test[position];
}
char & operator[](size_t position) // 先调用const版本的操作符，然后去掉返回结果的const属性
{
return
const_cast<char&>(
static_cast<const TextBlock&>(*this)[position]);
}
private:
string test;
};

int main()
{
TextBlock tb("Hello");
cout << tb[0] << endl;
const TextBlock ctb("World");
cout << ctb[0] << endl;

system("pause");
return 0;
}

六.指向对象的常指针

       将指向对象的指针变量声明为const型并将之初始化，这样指针值始终保持为其初始值，不能改变，即其指向始终不变。如：

int a = 1 , b;
int * const ptr1 = &a;
ptr1 = &b;// error C3892: “ptr1”: 不能给常量赋值

       指向对象的常指针的值不能改变，即始终指向同一个对象，但可以改变其所指向对象（如b）中数据成员的值。
七.指向常对象的指针

1.如果一个变量已经被声明为常变量，只能用指向常变量的指针指向它，而不能用一般的（指向那个非const型变量的）指针变量去指向它。

2.指向常变量的指针除了可以指向常变量，还可以指向非const变量。此时不能通过指针变量改变该变量的值。
3.指向常对象的指针常作为函数参数。



八.对象的常引用

       在C++面向对象程序设计中，经常用常指针和常引用作函数参数。这样既能保证数据安全，使数据不能被随意修改，在调用函数时又不必建立实参的拷贝。