简化 const 重载？

Question

我多年来一直教授 C++ 编程课程，向学生解释的最棘手的事情之一就是 const 重载。我通常使用类似向量的类及其 operator[] 函数的示例：

template <typename T> class Vector {
public:
    T& operator[] (size_t index);
    const T& operator[] (size_t index) const;
};

我可以轻松地解释为什么有两个版本的 operator[]函数是必要的，但在试图解释如何将两种实现统一在一起时，我经常发现自己在语言奥秘上浪费了大量时间。 是，我知道如何根据另一个函数实现其中​​一个函数的唯一好的、可靠的方法是使用 const_cast/static_cast 技巧：

template <typename T> const T& Vector<T>::operator[] (size_t index) const {
     /* ... your implementation here ... */
}
template <typename T> T& Vector<T>::operator[] (size_t index) {
    return const_cast<T&>(static_cast<const Vector&>(*this)[index]);
}

问题 这种设置的缺点是解释起来非常棘手，而且在直观上一点也不明显。当你将其解释为“强制转换为 const，然后调用 const 版本，然后剥离 constness”时，它更容易理解一点，但实际语法令人恐惧。解释什么是 const_cast ，为什么它在这里适用，以及为什么它在其他地方几乎普遍不合适，通常需要我五到十分钟的演讲时间，并且理解整个表达式通常需要比区分之间的差异更多的努力。 const T* 和 T* const。我觉得学生需要了解 const 重载以及如何做到这一点，而不需要在两个函数中不必要地重复代码，但在 C++ 编程入门课程中，这个技巧似乎有点过分了。

我的问题是 - 是否有一种更简单的方法来实现 const 重载函数？或者有没有更简单的方法来向学生解释这个现有的技巧？

Answer 1

我通常认为这是一种语言限制，并建议人们 - 除非他们真的知道自己在做什么 - 他们应该重新实现。在绝大多数情况下，这些函数都是简单的单行 getter，因此没有什么痛苦。

以您教授 C++ 的能力，我对这种方法的感受会更加强烈。

Answer 2

简单地将其分解为更小的步骤怎么样？

const Vector<T>& const_this = *this;
const T& const_elem = const_this[index];
T& mutable_elem = const_cast<T&>(const_elem);
return mutable_elem;

您甚至可以通过这种方式消除 static_cast，不过如果您认为更清晰，也可以将其保留。

Answer 3

这是一个相当奇怪的选项，但这可以使用像这样的静态模板帮助器来完成

// template parameters can be const or non-const
template<class Ret, class C>
static Ret& get(C* p, size_t index) { /* common code here like p->array[index] */ }

然后你可以写

const T& operator[](size_t index) const { return get<const T>(this, index); }
T& operator[](size_t index) { return get<T>(this, index); }

这个技巧避免了强制转换（！）和双重实现，但是，对我来说，它看起来很奇怪:)

还有一个关于的小评论您的代码片段，用 const_cast 代替 static_cast 还不够吗，还是我遗漏了一些东西？

Answer 4

您可以使用私有方法删除一个强制转换：
它添加了一个方法，但使转换变得不那么复杂：

template <typename T>
class Vector
{
  public:
    T const& operator[](size_t i) const { return getValue(i);}
    T&       operator[](size_t i)       { return const_cast<T&>(getValue(i));}

  private:
    T const& getValue(size_t i) const   { return /* STUFF */;}
};

Answer 5

在我看来，这很愚蠢。您强制一个方法根据另一个方法来实现只是为了这样做，而不是因为生成的代码更容易维护或理解。你的学生感到困惑的原因可能是因为他们应该如此。

并非所有原则都应该极端化。有时候，冗余反而更好。

Answer 6

您可以让两个版本都调用一个帮助函数来查找正确的项目，而不是让一个版本调用另一个版本。您似乎已经引入了模板，因此让辅助函数也成为模板应该可以工作并避免代码重复，并且可以在没有任何 const_cast 的情况下适用于 const 和非常量。

或者，您可以使用局部变量来帮助将表达式分解为可管理的部分（每个部分都有注释）。

const ClassType& cthis = *this; // look, no explicit cast needed here :)
const T& elem = cthis[index]; // delegate to const version
return const_cast<T&>(elem); // ok to strip off the const, since we added it in the first place

Answer 7

如果实现将使用完全相同的代码（对于这个“向量”类示例或其他），那么为什么不让非常量版本调用常量版本，而不是相反。如果由于某种原因代码必须修改成员，那么也许不应该真正存在 const 版本（忽略整个可变的事情......）。