将常量传播到成员变量指向的数据

Question

对于 C++ 新手来说，const 成员函数可以对类引用的对象（通过指针或引用）调用非常量方法，这常常是相当令人困惑的。例如，以下内容是完全正确的：

class SomeClass
{
    class SomeClassImpl;
    SomeClassImpl * impl_; // PImpl idiom

  public:    

    void const_method() const;
};

struct SomeClass::SomeClassImpl
{
    void non_const_method() { /*modify data*/ }
};

void SomeClass::const_method() const
{
    impl_->non_const_method(); //ok because impl_ is const, not *impl_
};

但是，如果常量传播到指向的对象，有时会相当方便（我自愿使用 PImpl 习惯用法，因为这是我认为“常量传播”非常有用的情况之一）。

使用指针时，可以通过使用某种带有常量重载运算符的智能指针来轻松实现这一点：

template < typename T >
class const_propagating_ptr
{
  public:

    const_propagating_ptr( T * ptr ) : ptr_( ptr ) {}

    T       & operator*()       { return *ptr_; }
    T const & operator*() const { return *ptr_; }

    T       * operator->()       { return ptr_; }
    T const * operator->() const { return ptr_; }

    // assignment operator (?), get() method (?), reset() method (?)
    // ...

  private:

    T * ptr_;
};

现在，我只需将 SomeClass::impl_ 修改为 const_propagating_ptr即可。 以获得所需的行为。

所以我对此有几个问题：

1. 是否有一些我忽略的常量传播问题？
2. 如果没有，是否有任何库提供类来获得常量传播？
3. 常见的智能指针（unique_ptr、shared_ptr 等）提供一些获取此行为的方法（例如通过模板参数）不是很有用吗？

Answer 1

1. 正如 @Alf P. Steinbach 所指出的，您看到了这样一个事实：复制指针会产生一个指向同一底层对象的非常量对象。 Pimpl（如下）通过执行深度复制很好地规避了该问题，unique_ptr 通过不可复制来规避该问题。当然，如果被指点者由单个实体拥有，那就容易得多。

2. 传播常量性，但它并不完全是一个指针（尽管它模拟了OptionalPointee 概念）。据我所知，没有这样的其他库。

3. 我希望他们默认提供它。添加另一个模板参数（我猜是特征类）似乎不值得这么麻烦。然而，这将从根本上改变经典指针的语法，所以我不确定人们是否准备好接受它。

---

Pimpl 类的代码

template <class T>
class Pimpl
{
public:
  /**
   * Types
   */
  typedef T value;
  typedef const T const_value;
  typedef T* pointer;
  typedef const T* const_pointer;
  typedef T& reference;
  typedef const T& const_reference;

  /**
   * Gang of Four
   */
  Pimpl() : _value(new T()) {}
  explicit Pimpl(const_reference v) : _value(new T(v)) {}

  Pimpl(const Pimpl& rhs) : _value(new T(*(rhs._value))) {}

  Pimpl& operator=(const Pimpl& rhs)
  {
    Pimpl tmp(rhs);
    swap(tmp);
    return *this;
  } // operator=

  ~Pimpl() { boost::checked_delete(_value); }

  void swap(Pimpl& rhs)
  {
    pointer temp(rhs._value);
    rhs._value = _value;
    _value = temp;
  } // swap

  /**
   * Data access
   */
  pointer get() { return _value; }
  const_pointer get() const { return _value; }

  reference operator*() { return *_value; }
  const_reference operator*() const { return *_value; }

  pointer operator->() { return _value; }
  const_pointer operator->() const { return _value; }

private:
  pointer _value;
}; // class Pimpl<T>

// Swap
template <class T>
void swap(Pimpl<T>& lhs, Pimpl<T>& rhs) { lhs.swap(rhs); }

// Not to be used with pointers or references
template <class T> class Pimpl<T*> {};
template <class T> class Pimpl<T&> {};

Answer 2

一种方法是不直接使用指针，除非通过两个访问器函数。

class SomeClass
{
  private:
    class SomeClassImpl;
    SomeClassImpl * impl_; // PImpl idiom - don't use me directly!

    SomeClassImpl * mutable_impl() { return impl_; }
    const SomeClassImpl * impl() const { return impl_; }

  public:    

    void const_method() const
    {
      //Can't use mutable_impl here.
      impl()->const_method();
    }
    void non_const_method() const
    {
      //Here I can use mutable_impl
      mutable_impl()->non_const_method();
    }
};

Answer 3

作为记录，我刚刚发现 Loki 库 确实提供了一个 const 传播指针（ConstPropPtr）。它看起来就像问题中的那个，除了它还删除其析构函数中的包装指针，并且它用于实现 Pimpl 类 类似于 @Matthieu 提议的（但不可复制）。

Answer 4

如果您认为它应该“传播”常量，那么这意味着您并不真正相信它是一个指针（或引用），但您相信它是一个容器：如果当对象不变时值也不变，这是因为对象包含该值。

因此，复制对象会复制值，至少在逻辑上（CoW）。

如果你坚持认为它是一个指针/引用IOW，你可以在共​​享所包含的值的同时复制对象，那么你就有一个不健全（矛盾）的接口。

结论：下定决心。它要么是一个容器，要么是一个指针。

根据定义，指针不会传播常量性。