const和mutable对于书写安全代码来说是个很有利的工具，坚持使用它们。
Problem
Guru Question
在下面代码中，在只要合适的情况下，对const进行增加和删除（包括一些微小的变化和一些相关的关键字）。注意：不要注释或者改变程序的结构。这个程序只作为演示用途。
另外：程序的哪些地方是由于错误地使用const而导致的未定义行为或不可编译？
class polygon {
public:
polygon() : area{-} {}
void add_point( const point pt ) { area = -;
points.push_back(pt); }
point get_point( const int i ) { return points[i]; }
int get_num_points() { return points.size(); }
double get_area() {
if( area < ) // if not yet calculated and cached
calc_area(); // calculate now
return area;
}
private:
void calc_area() {
area = ;
vector<point>::iterator i;
for( i = begin(points); i != end(points); ++i )
area += /* some work using *i */;
}
vector<point> points;
double area;
};
polygon operator+( polygon& lhs, polygon& rhs ) {
auto ret = lhs;
auto last = rhs.get_num_points();
for( auto i = ; i < last; ++i ) // concatenate
ret.add_point( rhs.get_point(i) );
return ret;
}
void f( const polygon& poly ) {
const_cast<polygon&>(poly).add_point( {,} );
}
void g( polygon& const poly ) { poly.add_point( {,} ); }
void h( polygon* const poly ) { poly->add_point( {,} ); }
int main() {
polygon poly;
const polygon cpoly;
f(poly);
f(cpoly);
g(poly);
h(&poly);
}
Stop and thinking….
Solution
当我提出这类问题的时候，我发现大多数人认为这个问题很容易，并且通常解决的只是一般的const问题。但是这里面有很多细微的差别我们应该知道，所有有了这篇blog
1.point对象按值传递，因此这里声明为const有一点点好处
void add_point( const point pt )
在这种特殊情况下，因为函数定义为inline，这里的const值参数（value parameter）就变得有意义了。这是因为inline函数的声明和定义是在同一处，否则，const值参数只应该出现在定义中，而不是声明中。让我们来看看为什么。
在函数声明中，往值参数中添加const对于函数来说是无关重要的，它对于调用者来说毫无意义且常常会起到迷惑作用。对于编译器来说，函数的签名不管是否在值参数前加入const都是相同的。
// value parameter: top-level const is not part of function signature
int f( int );
int f( const int ); // redeclares f(int): this is the same function // non-value parameter: top-level const is part of function signature
int g( int& );
int g( const int& ); // overloads g(int&): these are two functions
在值参数前加const的确会影响到它在函数体内的实际定义。记住，在函数体内，形参只是第一组局部变量。因此在值参数前加const仅仅意味着在函数内不能修改这个局部变量，这个只发生在参数上。下面是一个例子。
int f( int ); // declaration: no const
int f( const int i ) { // definition: use const to express "read-only"
vector<int> v;
v.push_back(i); // ok, only reads from i
i = ; // error, attempts to modify i
}
Guideline：在向前声明一个函数时，不要再传值参数前加入const。你可以在定义处加上const来表达一个只读参数。
2.get_point和get_num_points应该是const
point get_point( const int i ) { return points[i]; }
int get_num_points() { return points.size(); }
以上函数应该被标识为const，因为他们没有改变对象的状态。
3.get_area应该是const
double get_area() {
if( area < ) // if not yet calculated and cached
calc_area(); // calculate now
return area;
}
尽管这个函数在内部修改了对象的内部状态，我们也应该考虑将它标识为const，为什么？因为这个函数没有修改这个对象的可观察状态（observable state），我们只是在这做了写缓存动作，这只是内部的一些实现细节。这个对象在逻辑上依然是const，尽管它在物理上（physically）不是。
4.根据3，calc_area也应该是const
void calc_area() {
area = ;
vector<point>::iterator i;
for( i = begin(points); i != end(points); ++i )
area += /* some work using *i */;
}
一旦我们把get_area标识为const，这个私有的辅助函数也应该是const的，反过来说，一旦将这个函数标识为const，编译器就会告知你同样应在成员变量area上做出改变：
· 声明为mutable，这样它在const函数中就具有可写性（writable）
· 使用mutex或使之为atomic<>来同步，这样就具有并发安全性，像GotW #6a中讨论的那样。
5.同样，calc_area应该使用const_iterator
迭代器不应该改变points集合的状态，因此它应该是const_iterator。如果我们将calc_area标识为const成员函数的话，那我们无论如何都会做出这个改变。但是有一点要注意的是，如果我们在for中为迭代器使用auto的话，那么我们在这个上可以完全不做改变。当我们在cal_area内做for循环时，我们应该优先使用range-based for循环，同样包括auto.
组合上述所说，我们得到了下面的代码:
for( auto& pt : points )
area += /* some work using pt */;
Guidline: 优先使用auto来声明变量。
Guideline: 当要顺序访问集合元素时，优先使用rang-based for循环。
6.area应该是mutable和同步的
double area;
像上述所说，联合其他内部的变化，这个内部缓存变量area应该是mutable的，这样就可以在const成员函数中被安全和正确地使用，同时因为它是潜在的共享变量，那么就可能被多个const操作并发执行，因此它必须是同步的，使用mutex或使之为atomic。
额外提问：在继续阅读之前，它应该是：使用mutex来保护，还是使之为atomic<double>？
你有考虑过吗？我们继续...
上述两者都行，但是使用mutex对于单个变量来说有点过度（overkill）。
选项1是使用mutex，可能很快成为标准的"mutable mutex mutables"模式
// Option 1: Use a mutex
double get_area() const {
auto lock = unique_lock<mutex>{mutables};
if( area < ) // if not yet calculated and cached
calc_area(); // calculate now
return area;
}
private:
// ...
mutable mutex mutables; // canonical pattern: mutex that
mutable double area; // covers all mutable members
如果在未来要增加更多的数据成员的话，选项1会表现的不错。如果你在未来增加更多的使用了area变量的const成员函数的话，那么这个选项就变得很具有入侵性且变得不那么好了。因为在const成员函数内部应该在使用area之前在mutex请求锁。
选项2只是将double变成mutable atomic<double>。这个是很吸引人的，因为polygon的"mutable"部分只是一个单一变量。它能达到要求，但是你必须小心，因为这不是唯一必要的改变，原因有二：
· 次要原因是atomic<double>不支持+=操作。因此我们只是改变area的类型的话，calc_area是不会编译通过的。这有个变通方案，但也导致了主要原因。
· 主要原因是，因为calc_area是个组合操作，且必须能安全运行在多线程并发的情况下，我们必须重构calc_area函数，让它能够安全地并发执行。特别是它不应该执行完一次操作立马更新area，同时要确保多个并发竞争跟新area不会引起覆盖导致写入的值丢失。
有几个方法来达到上述要求，但是最简单的可能是在并发调用calc_area的情况下允许良性的冗余再计算。因为它不可能比阻塞并发调用（无论如何都必须等待）更差。
// Option 2: Use an atomic
void calc_area() const {
auto tmp = 0.0; // do all the work off to the side
for( auto& pt : points )
tmp += /* some work using pt */;
area = tmp; // then commit with a single write
}
private:
// ...
mutable atomic<double> area;
需要注意的是，调用calc_area的并发const操作依然会重叠和覆盖相互间的结果。但它是良性的，因为这些操作是并发的const操作，因此它们全部计算相同的值。同样，在并发的calc_area调用的循环中使用共享points变量，这会使得我们考虑检查它不会导致缓存竞争，因为这些都是读操作，所以不会。
7.operator+的rhs参数应该是const引用
polygon operator+( polygon& lhs, polygon& rhs ) {
rhs参数应该是const引用。
Guideline：如果你只是准备进行读取（而不是拷贝），那么优先使用只读参数，通过const&。
对于lhs：
8.operator+的lhs应该是传值
这个关键部分是我们无论如何都要对它进行拷贝：
auto ret = lhs;
当你处在“无论如何都要对一个只读参数进行拷贝”的特殊情况下，有几种方式可以接受这样的参数，我会在其他GotW中详细讨论其中的细节。但是对于现在的情况来说，不需要考虑的太多，简单地使用传值就足够了。其中有些优点我们已经在GotW #4中讨论过了。
· 如果调用方传入一个命名的polygon对象（一个左值），这不会有区别。传const引用紧随其后是一个显式的拷贝，传值将会执行一次拷贝
· 如果调用方传入的是一个临时polygon对象（一个右值），编译器会自动地移动构造（move-constructs）lhs，对于一些小的类型来说可能不会有太大区别，比如polygon，但是对于其他类型来说却是相对“便宜”的
Guideline: 如果无论如何都需要对参数进行拷贝，优先使用传值参数。因为它可以从rvalue参数进行移动操作。
9.在operator+中，last应该是const
auto last = rhs.get_num_points();
for( auto i = ; i < last; ++i ) // concatenate
ret.add_point( rhs.get_point(i) );
return ret;
}
因为last不应该被改变，所以可是使之为const
Guideline：如果变量不会被改变，那么优先选择使这些变量为const，包括局部变量。
顺便说一下，一旦我们把rhs改变成const引用，我们也能明白为什么get_point变为const成员函数的另一个原因。
10.f的const_cast可能会导致未定义行为
void f( const polygon& poly ) {
const_cast<polygon&>(poly).add_point( {,} );
}
如果引用的对象声明为const的话，那么const_cast的结果是未定义的。就像在f(cpoly)这种情况。
这个参数不是真正的const，所以没有声明为const，接着试图去修改它。这是在欺骗编译器，可能对于调用者来说没有关系，但是个坏主意。
11.g的const是非法且无用的
void g( polygon& const poly ) { poly.add_point( {,} ); }
这个const是非法的:不能直接将const应用在引用本身，除了引用本身已经是const，因为它们不能不能被复位去引用到另一个对象。
void h( polygon* const poly ) { poly->add_point( {,} ); }
h的const仅仅只是确保在h函数体内不会修改指针。和add_pont与get_point的const参数是一样的。
12.检查主程序
int main() {
polygon poly;
const polygon cpoly;
f(poly);
没问题。
f(cpoly);
就像上面说的那样，当f试图去擦除参数的常量性后修改其值会导致未定义的结果。
g(poly);
没问题。
h(&poly);
没问题。
Summary
下面是一个修改后的版本。不要试图去修改任何的差的代码风格。因为现在修改成了atomic成员，它是不可拷贝的（copyable），所以现在提供了一个copy和move操作。
class polygon {
public:
polygon() : area{-} {}
polygon( const polygon& other ) : points{other.points}, area{-} { }
polygon( polygon&& other )
: points{move(other.points)}, area{other.area.load()}
{ other.area = -; }
polygon& operator=( const polygon& other )
{ points = other.points; area = -; return *this; }
polygon& operator=( polygon&& other ) {
points = move(other.points);
area = other.area.load();
other.area = -;
return *this;
}
void add_point( point pt )
{ area = -; points.push_back(pt); }
point get_point( int i ) const { return points[i]; }
int get_num_points() const { return points.size(); }
double get_area() const {
if( area < ) // if not yet calculated and cached
calc_area(); // calculate now
return area;
}
private:
void calc_area() const {
auto tmp = 0.0;
for( auto& pt : points )
tmp += /* some work using pt */;
area = tmp;
}
vector<point> points;
mutable atomic<double> area;
};
polygon operator+( polygon lhs, const polygon& rhs ) {
const auto last = rhs.get_num_points();
for( auto i = ; i < last; ++i ) // concatenate
lhs.add_point( rhs.get_point(i) );
return lhs;
}
void f( polygon& poly ) { poly.add_point( {,} ); }
void g( polygon& poly ) { poly.add_point( {,} ); }
void h( polygon* poly ) { poly->add_point( {,} ); }
int main() {
auto poly = polygon{};
f(poly);
g(poly);
h(&poly);
}
原文链接：http://herbsutter.com/2013/05/28/gotw-6b-solution-const-correctness-part-2/