C++程序中尽可能使用const

const

用在变量声明和定义式中，用以为变量提供语义约束，说明该变量是不可以改变的，可用以修饰全局变量、局部变量、静态变量、类成员变量以及定义常量指针和指针常量。

const

修饰

STL

迭代器

STL

（标准模板库）的迭代器的作用类似于指针，声明迭代器为

const

,类似与定义一个常量指针，可以改变迭代器指向的变量的值，但不能将迭代器指向不同的变量。如果希望迭代器是一个指针常量，可以使用

const_iterator

类型定义迭代器，它声明指向的变量的内容不可改变，但迭代器本身的指向是可以改变的。

/*****************************************
* stl_iterator.cpp                      *
*                                       *
* const修饰标准模板库中的迭代器         *
*****************************************/

#include <iostream>
#include <vector>

int main()
{
std::vector<int> vec(10);
const std::vector<int>::iterator iter = vec.begin();

*iter = 10;
iter++;/*错误*/
std::cout<<"第一个元素为"<<*iter<<"\n";

std::vector<int>::const_iterator citer = vec.begin();
*citer = 20;/*错误*/
citer++;
std::cout<<"第二个元素为"<<*citer<<std::endl;

return 0;
}

注释掉错误代码，编译运行。

函数返回

const

值

函数返回常量值可以降低因函数的错误使用而造成的意外。

/****************************************
* const_function_return.cpp            *
*                                      *
* 函数返回const值                      *
****************************************/

#include <iostream>

class Rational
{
private:
int x;

public:
Rational(int x)
{
this->x = x;
}

public:
int GetX() const{return x;}

};

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

int main()
{
Rational a(3);
Rational b(4);

Rational c = a * b;

std::cout<<"c中的x为"<<c.GetX()<<std::endl;

return 0;
}

如果在函数返回时不指定

const

，则下面的程序也是允许的.

/****************************************
* const_function_return.cpp            *
*                                      *
* 函数返回const值                      *
****************************************/

#include <iostream>

class Rational
{
private:
int x;

public:
Rational(int x)
{
this->x = x;
}

public:
int GetX() const{return x;}

};

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

int main()
{
Rational a(3);
Rational b(4);

Rational c(10);
(a * b) = c;

std::cout<<"a中的x为"<<a.GetX()<<std::endl;
std::cout<<"b中的x为"<<b.GetX()<<std::endl;
std::cout<<"c中的x为"<<c.GetX()<<std::endl;

return 0;
}

而这样的表达式不符合基本运算规则，而且没有影响。出现这种情况很可能是在输入时候将

==

错输入为

=

。

const

成员函数

const

成员函数可作用于

const

对象。

在

C++

中，

const

成员函数和相应的非

const

成员函数是可以重载的。

在

const

成员函数中无法修改它的成员变量，若确实要在

const

成员函数中修改成员变量，在需要类的成员变量的定义式中使用

mutable

修饰符。

/****************************************
* const_mutable.cpp                    *
*                                      *
* Const成员函数修改对象属性            *
****************************************/

#include <iostream>

class Number
{
private:
int x;
public:
Number(int _x)
{
x = _x;
}

public:
int GetX() const
{
x = 2 * x;
return x;
}

void PrintX()
{
std::cout<<"x = "<<x<<std::endl;
}
};
int main()
{
Number a(10);
a.GetX();
a.PrintX();
return 0;
}

修改

x

的定义式为：

class Number
{
private:
mutable int x;
...

则可以在

const

成员函数

GetX

中修改

x

变量的值，程序正常运行。

在非

const

成员函数中调用

const

成员函数避免代码重复

/****************************************
* nonconst_call_const.cpp              *
*                                      *
* 在非const成员函数中调用const成员函数 *
* 避免代码重复                         *
****************************************/

#include <iostream>

class TextBlock
{
private:
const char *pText;
public:
TextBlock(const char *_pText)
{
pText = _pText;
}

public:
const char& operator[](std::size_t position) const
{
return pText[position];
}

char& operator[](std::size_t position)
{
return const_cast<char&>(static_cast<const TextBlock&>(*this)[position]);
}
};
int main()
{
TextBlock a("Hello World");
const TextBlock b("World");

std::cout<<"a的第一个字符为"<<a[0]<<std::endl;
std::cout<<"b的第一个字符为"<<b[0]<<std::endl;
return 0;
}

例子中非

const

的下标重载运算符调用

const

下标重载运算符，实现字符访问。涉及两类转换，第一类是从

Text&

到

const Text&

的静态转换，使用

static_cast

，一类是返回值由

const char&

转换为

const

使用

const_cast

去处常量标志。

参考文献

Scott Meyers著，侯捷译. Effective C++中文版. 电子工业出版社. 2012.