Распространение константности на данные, на которые указывают переменные-члены

1. Как отметил @Alf P. Steinbach, вы наблюдали за тем, что копирование вашего указателя приведет к получению неконстантного объекта, указывающего на тот же базовый объект. Pimpl (ниже) прекрасно обходит проблему, выполняя глубокое копирование, unique_ptr обходит ее, не допуская копирования. Конечно, гораздо проще, если указатель принадлежит одному лицу.

2. Boost.Optional распространяет const -ness, однако это не совсем указатель (хотя он моделирует концепцию 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&> {};

Один подход состоит в том, чтобы просто не использовать указатель напрямую, кроме как через две функции доступа.

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();
    }
};

Для справки: я только что узнал, что библиотека Loki действительно предоставляет константный распространяющийся указатель (ConstPropPtr<T>). Он выглядит так же, как и в вопросе, за исключением того, что он также удаляет обернутый указатель в своем деструкторе и используется для реализации Pimpl class аналогично предложенный @Matthieu (но не копируемый).

Если вы считаете, что он должен «распространять» константность, то это означает, что вы на самом деле не верите, что это указатель (или ссылка), но вы верите, что это контейнер: если значение является постоянным, когда объект является постоянным, это происходит потому, что объект содержит значение.

Таким образом, копирование объекта копирует значение, по крайней мере, логически (CoW).

Если вы настаиваете на том, что это IOW указателя/ссылки, что вы можете копировать объект при совместном использовании содержащегося значения, то у вас есть ненадежный (противоречивый) интерфейс.

Вывод: примите решение. Это либо контейнер, либо указатель.

Указатель не распространяет константность по определению.