如何防止使用继承的运算符 [] 进行赋值？

Question

我有一个名为SortedArrayList<T> 的自定义结构，它根据比较器对其元素进行排序，我想防止使用operator[] 进行分配。

示例：

ArrayList.h

template <typename T> class ArrayList : public List<T> {
    virtual T& operator[](const int& index) override; //override List<T>
    virtual const T operator[](const int& index) const override; //override List<T>
}

带有以下运算符的 SortedLinkedList.h

template <typename T> class SortedArrayList : public ArrayList<T> {
   public:

   SortedArrayList<T>(const std::function<bool(const T&, const T&)>& comparator);

   T& operator[](const int& index) override; //get reference (LHS)
   const T operator[](const int& index) const override; //get copy (RHS)
}

测试.h

ArrayList<int>* regular = new ArrayList<int>();
ArrayList<int>* sorted = new SortedArrayList<int>(cmpfn);

(*regular)[0] == 5; //allow
(*regular)[0] = 5;  //allow
(*sorted)[0] == 7; //allow
(*sorted)[0] = 7; //except

这个操作可以吗？

阻止我的意思是抛出异常或警告用户不要这样做的东西。

Answer 1

比继承更喜欢聚合：

template <typename T> class SortedArrayList {
   ArrayList<T> m_the_list;
   public:

   SortedArrayList<T>(const std::function<bool(const T&, const T&)>& comparator);

   const T& operator[](const int& index) const {return m_the_list[index];}; // always get const reference

   // Can act as a *const* ArrayList<T>, but not as a mutable ArrayList<T>, as that would violate Liskov's substitution principle.
   operator const ArrayList<T>&() const {return m_the_list;}
}

正如Stephen Newell 正确的points out，当您使用继承时，您保证您的类SortedArrayList 可以在所有可能的情况下充当ArrayList。在您的示例中显然不是这种情况。

您可以阅读更多here，了解如何违反 Liskov 的替代原则是一个坏主意。

Answer 2

你不应该这样做。它表示设计不当 请参阅the C++ FAQ on Inheritance。如果您的子类不能以所有方式用作基类 (LSP)，则它不满足公共继承的“is-a”要求。

如果你想拥有一种允许成员替换的容器和另一种不允许成员替换的容器，那么定义只允许 const 成员访问的基类（无需将其设为虚拟）。然后从那里分支到MutableList和ImmutableList，让SortedArrayList派生自Immutable列表。

Answer 3

在我看来，这里的最佳做法是实现at(const int& index) 方法，而不是重载[]。无论如何，这对界面的用户来说会更清楚。

std::map 和其他std 数据结构中也有类似的功能。例如：http://www.cplusplus.com/reference/map/map/at/

Answer 4

1. 您为什么将索引作为参考传递？完全不需要……
2. 我个人建议对数组索引使用无符号整数类型（无论如何，负索引的含义是什么？？？）。
3. 由 value 返回的类型的 const （几乎）没有意义 - 无论如何它都会被复制到另一个变量（然后 将 是可修改的），但是您会阻止移动语义...

所以：

T& operator[](unsigned int index); //get reference (LHS)
T operator[](unsigned int index) const; //get copy (RHS)

（只是一些改进建议......）

现在回到实际问题：禁止修改非常简单：

//T& operator[](unsigned int index); //get reference (LHS)
T const& operator[](unsigned int index) const; //get copy (RHS)

只有一个索引运算符，总是返回 const 引用...如果用户可以使用引用，很好，否则他/她无论如何都会复制该值...

根据修改后的问题进行编辑：

由于涉及到继承，事情变得更加复杂。您不能仅仅摆脱某些继承的函数，而继承的函数将允许元素修改。

在给定的情况下，我会考虑重新设计（如果可能的话）：

class ArrayListBase
{
public:
    T const& operator[](unsigned int index) const;
    // either copy or const reference, whichever appears more appropriate to you...
};

class ArrayList : public ArrayListBase
{
public:
    using ArrayListBase::operator[];
    T& operator[](unsigned int index);
}


class SortedArrayList : public ArrayListBase
{
public:
    // well, simply does not add an overload...
}

插入函数可能是基类中的纯虚函数（其中一个通用接口似乎很合适）或仅在派生类中可用。决定你...