如何处理const对象中非常量引用成员的初始化？

假设你有课

    class C 
    {
      int * i;

      public:

         C(int * v):i(v) {};

         void method() const;  //this method does not change i
         void method();        //this method changes i
    }

现在您可能想要定义此类的 const 实例

    const int * k = whatever;
    const C c1(k); //this will fail

但这会失败，因为非常量 int C 的构造函数 C(int * v)

所以你定义了一个 const int 构造函数

    C(const int * v):i(v) {}; //this will fail also

但这也会失败，因为 C 的成员“int * i”是非常量。

遇到这种情况该怎么办？使用可变的？铸件？准备类的常量版本吗？

编辑：在与帕维尔（如下）讨论后，我对这个问题进行了一些研究。对我来说，C++ 的做法是不正确的。指针目标应该是严格类型，这意味着您不能执行以下操作：

int i;
const int * ptr;
ptr = & i;

在这种情况下，语言语法对待const作为不改变指针目标的承诺。此外int * const ptr是一个不改变指针值本身的承诺。因此，有两个地方可以应用 const。那么您可能希望您的类对指针进行建模（为什么不呢）。事情正在分崩离析。 C++ 语法提供了 const 方法，这些方法能够保证不会更改字段的值本身，但没有语法指出您的方法不会更改类内指针的目标。

解决方法是定义两个类const_C and C例如。然而，这不是一条皇家道路。使用模板，它们的部分专业化很难不陷入混乱。还有所有可能的参数变化，例如const const_C & arg, const C & arg, const_C & arg, C & arg看起来不漂亮。我真的不知道该怎么办。使用单独的类或const_casts，每种方式似乎都是错误的。

在这两种情况下，我是否应该将不修改指针目标的方法标记为 const？或者只是遵循传统路径，即 const 方法不会更改对象本身的状态（const 方法不关心指针目标）。那么在我的例子中，所有方法都是 const，因为类正在建模一个指针，因此指针本身就是T * const。但显然其中一些修改了指针的目标，而另一些则没有。

听起来你想要一个可以包装的对象int*（然后表现得非常量），或者int const*（然后表现为 const）。仅靠一个类是无法真正做到这一点的。

事实上，正是这个概念const应用于你的类应该改变它的语义，就像这是错误的 - 如果你的类建模了一个指针或一个迭代器（如果它包装了一个指针，很可能是这种情况），那么const应用于它仅意味着它本身不能更改，并且不应暗示与所指向的值有关的任何内容。您应该考虑遵循 STL 对其容器所做的事情 - 这正是它具有独特之处的原因iterator and const_iterator类，两者是不同的，但前者可以隐式转换为后者。同样，在 STL 中，const iterator不等于const_iterator！所以就做同样的事情吧。

[EDIT]这是一种最大限度地重用代码之间的棘手方法C and const_C同时确保自始至终的常量正确性，而不是深入研究 U.B. （和const_cast):

template<class T, bool IsConst>
struct pointer_to_maybe_const;

template<class T>
struct pointer_to_maybe_const<T, true> { typedef const T* type; };

template<class T>
struct pointer_to_maybe_const<T, false> { typedef T* type; };

template<bool IsConst>
struct C_fields {
   typename pointer_to_maybe_const<int, IsConst>::type i;
   // repeat for all fields
};


template<class Derived>
class const_C_base {
public:
    int method() const { // non-mutating method example
        return *self().i;
    }
private:
    const Derived& self() const { return *static_cast<const Derived*>(this); }
};

template<class Derived>
class C_base : public const_C_base<Derived> {
public:
    int method() { // mutating method example
        return ++*self().i;
    }
private:
    Derived& self() { return *static_cast<Derived*>(this); }
};


class const_C : public const_C_base<const_C>, private C_fields<true> {
    friend class const_C_base<const_C>;
};

class C : public C_base<C>, private C_fields<false> {
    friend class C_base<C>;
};

如果您实际上只有很少的字段，那么在两个类中复制它们可能比使用结构更容易。如果有很多，但它们都是同一类型，那么直接将该类型作为类型参数传递会更简单，而不必费心const包装模板。