允许成员为常量，同时仍然支持类上的operator=

Question

我的类中有几个成员是 const，因此只能通过初始化列表进行初始化，如下所示：

class MyItemT
{
public:
    MyItemT(const MyPacketT& aMyPacket, const MyInfoT& aMyInfo)
        : mMyPacket(aMyPacket),
          mMyInfo(aMyInfo)
    {
    }

private:
    const MyPacketT mMyPacket;
    const MyInfoT mMyInfo;
};

我的类可以在一些内部定义的容器类（例如向量）中使用，并且这些容器要求在类中定义 operator=。

当然，我的operator=需要做这样的事情：

MyItemT&
MyItemT::operator=(const MyItemT& other)
{
    mMyPacket = other.mPacket;
    mMyInfo = other.mMyInfo;
    return *this;
}

这当然不起作用，因为mMyPacket和mMyInfo是const成员。

除了使这些成员成为非 const（我不想这样做）之外，还有关于如何解决此问题的任何想法吗？

Answer 1

如果您有一个赋值运算符可以在构造完成后更改它们，那么您就违反了 const 的定义。如果你真的需要，我认为 Potatoswatter 的放置新方法可能是最好的，但是如果你有一个赋值运算符，你的变量并不是真正的 const，因为有人可以创建一个新实例并使用它来更改它们的值

Answer 2

您可以存储指针（或智能指针），而不是直接在容器中存储对象。这样，您不必更改类的任何成员 - 您将返回与传入的对象完全相同的对象、const 等。

当然，这样做可能会在一定程度上改变应用程序的内存管理，这很可能是不想这样做的充分理由。

Answer 3

这是一个肮脏的黑客行为，但你可以自己销毁和重建：

MyItemT&
MyItemT::operator=(const MyItemT& other)
{
    if ( this == &other ) return *this; // "suggested" by Herb Sutter ;v)

    this->MyItemT::~MyItemT();
    try {
        new( this ) MyItemT( other );
    } catch ( ... ) {
        new( this ) MyItemT(); // nothrow
        throw;
    }
    return *this;
}

编辑：以免破坏我的可信度，我自己实际上不会这样做，我会删除const。然而，我一直在争论改变这种做法，因为 const 非常有用，并且尽可能使用更好。

有时，资源和对象表示的值之间存在区别。只要资源相同，成员就可以通过值的更改而成为 const，并且最好能够获得编译时安全性。

编辑2：@Charles Bailey提供了这个精彩的（并且非常关键的）链接： http://gotw.ca/gotw/023.htm。

• 在任何派生类 operator= 中，语义都很棘手。
• 它可能效率低下，因为它不调用已定义的赋值运算符。
• 它与不稳定的 operator& 重载（无论什么）
• 等

不兼容。 编辑 3： 通过思考“哪个资源”与“什么值”的区别，似乎很清楚 operator= 应该始终更改值而不是资源。那么资源标识符可以是const。在该示例中，所有成员都是const。如果“信息”是存储在“数据包”内的内容，那么数据包可能应该是 const 而信息不是。

因此，如果“信息”实际上是元数据，那么问题不在于弄清楚分配的语义，而在于在此示例中缺乏明显的值。如果拥有 MyItemT 的任何类想要将其从一个数据包切换到另一个数据包，则需要放弃并使用 auto_ptr 代替，或者诉诸类似的方法如上所述的 hack（身份测试是不必要的，但 catch 仍然存在）从外部实现。但是 operator= 不应该更改资源绑定，除非作为绝对不会干扰其他任何内容的额外特殊功能。

请注意，此约定与萨特关于在分配方面实施副本构造的建议很好地配合。

 MyItemT::MyItemT( MyItemT const &in )
     : mMyPacket( in.mMyPacket ) // initialize resource, const member
     { *this = in; } // assign value, non-const, via sole assignment method

Answer 4

我认为你可以使用特殊的 const 代理。

template <class T>
class Const
{
public:
  // Optimal way of returning, by value for built-in and by const& for user types
  typedef boost::call_traits<T>::const_reference const_reference;
  typedef boost::call_traits<T>::param_type param_type;

  Const(): mData() {}
  Const(param_type data): mData(data) {}
  Const(const Const& rhs): mData(rhs.mData) {}

  operator const_reference() const { return mData; }

  void reset(param_type data) { mData = data; } // explicit

private:
  Const& operator=(const Const&); // deactivated
  T mData;
};

现在，您将拥有 Const，而不是 const MyPacketT。并不是说该接口只提供了一种更改它的方法：通过显式调用reset。

我认为任何 mMyPacket.reset 的使用都可以很容易地被搜索到。正如 @MSalters 所说，它可以防止墨菲，而不是马基雅维利:)

Answer 5

您可以考虑将 MyPacketT 和 MyInfoT 成员设置为指向 const 的指针（或指向 const 的智能指针）。这样，数据本身仍然被标记为 const 和不可变的，但如果有意义的话，您可以在赋值中干净地“交换”到另一组 const 数据。事实上，您可以使用交换习惯以异常安全的方式执行分配。

因此，您可以利用 const 来帮助您防止意外允许您希望设计阻止的更改，但您仍然允许从另一个对象分配整个对象。例如，这将允许您在 STL 容器中使用此类的对象。

您可能会将其视为“pimpl”习语的特殊应用。

最后

#include <algorithm>    // for std::swap

#include "boost/scoped_ptr.hpp"

using namespace boost;

class MyPacketT {};
class MyInfoT {};


class MyItemT
{
public:
    MyItemT(const MyPacketT& aMyPacket, const MyInfoT& aMyInfo)
        : pMyPacket(new MyPacketT( aMyPacket)),
          pMyInfo(new MyInfoT( aMyInfo))
    {
    }

    MyItemT( MyItemT const& other)
        : pMyPacket(new MyPacketT( *(other.pMyPacket))),
          pMyInfo(new MyInfoT( *(other.pMyInfo)))
    {   

    }

    void swap( MyItemT& other) 
    {
        pMyPacket.swap( other.pMyPacket);
        pMyInfo.swap( other.pMyInfo);        
    }


    MyItemT const& operator=( MyItemT const& rhs)
    {
        MyItemT tmp( rhs);

        swap( tmp);

        return *this;
    }

private:
    scoped_ptr<MyPacketT const> pMyPacket;
    scoped_ptr<MyInfoT const> pMyInfo;
};

，我将示例更改为使用 scoped_ptr 而不是 shared_ptr 因为我认为它是更通用的表示OP 的意图。然而，如果“可重新分配”的 const 成员可以共享（考虑到我对为什么 OP 希望它们 const 的理解，这可能是真的），那么这可能是一种优化使用 shared_ptr<> 并让 shared_ptr<> 类的复制和赋值操作处理这些对象的事务 - 如果您没有其他成员需要特殊的副本或分配语义，那么您的类就会变得更加简单，并且您甚至可以通过共享 MyPacketT 和 MyInfoT< 的副本来节省大量内存使用量/代码> 对象。