5

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

我知道具有常量成员的对象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 与 const 类成员的麻烦所有答案结合在一起回答了我的问题。

4

4 回答 4

8

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

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

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

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

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

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

顺便说一句，您的赋值运算符是完全非惯用的并且会泄漏内存。如果您对学习 C++ 很认真，那么您应该阅读其中一本书。

于 2010-11-26T21:38:16.607 回答
3

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

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

const int i = 1;
i = 2;

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

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

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

于 2010-11-26T19:58:09.477 回答
3

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.

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

于 2010-11-26T20:21:07.477 回答
2

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

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

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

@ 2. 可以通过使用复制构造函数和所需属性创建一个新对象并返回它*。尽管您规避了 const 属性，但它仍然比完全不使用 const 更好，因为您将允许容器在这里作弊，但仍会阻止用户自己执行此操作，这是使该成员保持不变的初衷。

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

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

@4.没办法逼他。他不知道怎么做，因为变量是恒定的，并且在某些时候他必须this->row = other.row与int const row;先前定义的有关。即使在这种情况下， const 也意味着常量。一个来源

@ 5 QList 没有此类选项。

其他解决方案：

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

*目前不确定。

于 2010-11-26T22:10:50.840 回答