常量类成员、赋值运算符和 QList

Question

如果我是正确的，请确认并告诉我是否有更好的解决方案：

我了解具有int const width; 等常量成员的对象无法由编译器隐式创建的合成赋值运算符处理。但是 QList （我想也是 std::list ）需要一个有效的赋值运算符。因此，当我想使用具有常量成员和 QList 的对象时，我有三种可能性：

1. 不要使用常量成员。 （不是解决方案）
2. 实现我自己的赋值运算符。
3. 使用其他不需要分配的容器 运营商

正确吗？还有其他优雅的解决方案吗？

我也想知道我是否可以：

• (4) 强制编译器创建处理常量成员的赋值运算符！ （我不明白为什么这是一个这么大的问题。为什么操作员不够聪明，无法在内部使用初始化列表？还是我遗漏了什么？）
• (5) 告诉 QList 我永远不会在列表中使用赋值操作。

编辑：我自己从不分配此类的对象。它们仅由复制构造函数或重载构造函数创建。所以赋值运算符只有容器需要，我自己不需要。

EDIT2：这是我创建的赋值运算符。我不确定它是否正确。 Cell 有一个两个参数的构造函数。这些参数使用初始化列表设置两个常量成员。但该对象还包含其他变量（非 const）成员。

Cell& Cell::operator=(Cell const& other)
{
 if (this != &other) {
  Cell* newCell = new Cell(other.column(), other.row());
  return *newCell;
 }
 return *this;
}

EDIT3：我发现这个帖子几乎有相同的问题：C++: STL troubles with const class members 所有答案结合在一起回答了我的问题。

Answer 1

const 不代表“这个值只能在特殊情况下改变”。相反， const 的意思是“你不能用它做任何事情都会导致它以任何方式发生变化（你可以观察到）”

如果您有一个 const 限定变量，则编译器的命令（以及您自己选择首先用 const 限定它）不允许您做任何会导致它改变的事情。这就是const 所做的。尽管您采取了行动，但它可能会改变，如果它是对非 const 对象的 const 引用，或者出于任何其他原因。如果您作为程序员知道引用对象实际上不是常量，则可以使用const_cast 将其丢弃并更改它。

但在你的情况下，一个常量成员变量，这是不可能的。 const 限定变量不能是对非 const 的 const 引用，因为它根本不是引用。

编辑：关于这一切的激动人心的例子以及为什么你应该在 const 正确性方面表现自己，让我们看看真正的编译器实际上做了什么。考虑这个简短的程序：

int main() {
  const int i = 42; 
  const_cast<int&>(i) = 0; 
  return i;
}

这是 LLVM-G++ 发出的：

; ModuleID = '/tmp/webcompile/_2418_0.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-linux-gnu"

define i32 @main() nounwind {
entry:
  %retval = alloca i32                            ; <i32*> [#uses=2]
  %0 = alloca i32                                 ; <i32*> [#uses=2]
  %i = alloca i32                                 ; <i32*> [#uses=2]
  %"alloca point" = bitcast i32 0 to i32          ; <i32> [#uses=0]
  store i32 42, i32* %i, align 4
  store i32 0, i32* %i, align 4
  store i32 42, i32* %0, align 4
  %1 = load i32* %0, align 4                      ; <i32> [#uses=1]
  store i32 %1, i32* %retval, align 4
  br label %return

return:                                           ; preds = %entry
  %retval2 = load i32* %retval                    ; <i32> [#uses=1]
  ret i32 %retval2
}

特别感兴趣的是store i32 0, i32* %i, align 4 这一行。这表明const_cast 是成功的，我们实际上为 i 初始化的值分配了一个零。

但是 对 const 限定的修改不会导致可观察到的变化。因此，GCC 产生了一个相当长的链，将 42 放入 %0，然后将 42 放入 %1，然后将其再次存储到 %retval，然后将其加载到 %retval2。因此，G++ 将让这段代码满足这两个要求，const 被丢弃，但 i 没有明显的变化，main 返回 42。

---

如果您需要一个可以更改的值，例如在标准容器的元素中，那么您不需要const。

考虑使用带有公共 getter 和私有 setter 方法的 private: 成员。

Answer 2

我将尝试简单地捆绑答案：

主要问题是 QList 要求存在赋值运算符，因为它们在内部使用赋值。因此，它们将实现与接口混合在一起。因此，尽管您不需要赋值运算符 QList 没有它就无法工作。 source

@ 3. 有 std::List 但它不提供对元素的恒定时间访问，而 QList 提供。

@ 2. 可以通过使用复制构造函数和所需属性创建一个新对象并返回它*。虽然你绕过了 const 属性，但它仍然比不使用 const 更好，因为你会允许容器在这里作弊，但仍然阻止用户自己做这件事，这是让这个成员保持不变的初衷。

但要考虑到创建重载赋值运算符会增加代码的复杂性，并且可能会引入比成员的 const-ing 首先解决的错误更多的错误。

@ 1. 最后这似乎是最简单的解决方案。只要它是私有的，您只需要注意对象本身不会更改它。

@4. 没办法强迫他。他不知道怎么做，因为变量是恒定的，并且在某些时候他将不得不使用先前定义的int const row; 来执行this->row = other.row。即使在这种情况下， const 也意味着常量。 one source

@ 5 QList 没有此类选项。

其他解决方案：

• 使用指向对象的指针而不是纯对象

*目前不确定。

Answer 3

您可能是 C++ 的新手，并希望它的行为类似于 Python、Java 或 C#。

将不可变的 Java 对象放入集合中是很常见的。这是有效的，因为在 Java 中，您并没有真正将 Java objects 放入集合中，而只是将 Java references 放入到 Java 对象中。更准确地说，集合内部由 Java 引用变量组成，分配给这些 Java 引用变量根本不会影响被引用的 Java 对象。他们甚至没有注意到。

我特意说“Java 对象”、“Java 引用”和“Java 变量”，因为术语“对象”、“引用”和“变量”在 C++ 中具有完全不同的含义。如果你想要可变的T 变量，你想要可变的T 对象，因为变量和对象在C++ 中基本上是一回事：

一个变量是由一个对象的声明引入的。变量名表示对象。

在 C++ 中，变量不包含对象——它们是对象。赋值给变量意味着改变对象（通过调用成员函数operator=）。没有其他办法了。如果你有一个不可变对象，那么赋值a = b无法在不明确破坏类型系统的情况下工作，如果你这样做，那么你实际上是在向你的客户撒谎说对象是不可变的。做出承诺然后故意违背它是没有意义的，不是吗？

当然，您可以简单地模拟 Java 方式：使用一组 指针 指向不可变对象。这是否是一个有效的解决方案取决于您的对象真正代表什么。但仅仅因为这在 Java 中运行良好并不意味着它在 C++ 中运行良好。 在 C++ 中不存在不可变值对象模式。这在 Java 中是个好主意，在 C++ 中是个糟糕的主意。

顺便说一句，您的赋值运算符是完全非惯用的并且会泄漏内存。如果你认真学习 C++，你应该阅读one of these books。

Answer 4

(4) 不是一个选项。隐式声明的复制赋值运算符将右侧对象的每个成员分配给左侧对象的相同成员。

编译器无法为具有 const 限定数据成员的类隐式生成复制赋值运算符，原因与此无效：

const int i = 1;
i = 2;

(2) 是有问题的，因为您必须以某种方式克服同样的问题。

(1) 是显而易见的解决方案；如果您的类类型具有 const 限定的数据成员，则它是不可分配的，并且分配没有多大意义。为什么说这不是解决方案？

---

如果您不希望您的类类型可分配，那么您不能在要求其值类型可分配的容器中使用它。所有的 C++ 标准库容器都有这个要求。