Привести boost::shared_array‹char› к boost::shared_array‹const char›

Поскольку у shared_array нет метода add_ref, вы можете эмулировать его следующим образом:

struct MagicDeleter {
  MagicDeleter( boost::shared_array<char> ptr ) : ptr(ptr) {};
  template<typename T> void operator()(T*) {} 
protected:
  boost::shared_array<char> ptr;
};

...

boost::shared_array<char> orig_ptr( some_val );
boost::shared_array<const char> new_ptr( orig_ptr.get(), MagicDeleter(orig_ptr) );

Другие ответы правильные, вы не можете и не должны.

Кроме того, вы уверены, что хотите boost::shared_array<const char>, а не const boost::shared_array<char>?

Практически это работает:

boost::shared_array<char> acz;
boost::shared_array<const char>& acz2 = reinterpret_cast< boost::shared_array<const char>& >(acz);

НО это не очень хорошая идея и работает только в том случае, если boost::shared_array и boost::shared_array имеют одинаковую реализацию. Шаблоны могут быть частично специализированными:

template<class T>
struct TwoImplementations {
    int m_nIntMember;
};

template<>
struct TwoImplementations< const T > {
    double m_fDoubleMember;
};

Выполнение повторного приведения между TwoImplementations<int> и TwoImplementations<const int> просто неправильно.

Вы не можете.

Поскольку оба типа основаны на шаблоне, оба типа совершенно различны для компилятора.

Я думаю, ты не можешь. Однако, если вам это действительно нужно, вы можете создать собственный класс интеллектуальных указателей. Подсказки для этого можно найти здесь.

Вы можете использовать метод get() для получения базового char*, который автоматически преобразуется в const char*, но не назначайте его другому shared_array, потому что тогда данные будут удалены дважды. Просто используйте его по мере необходимости.

нравится:

boost::shared_array<char> x(new int[13]);
const char *y = x.get();

Я бы не подумал об этом без потрясающего ответа Кирилла, но вы можете эффективно расширить static_pointer_cast boost, который используется для shared_ptrs, для работы с shared_arrays следующим образом:

template<typename OriginalType>
struct SharedPtrCastHelper
{
  public:
    SharedPtrCastHelper( const OriginalType & ptr ) : ptr(ptr) {};
    template<typename T> void operator()(T*) {}

  protected:
    OriginalType ptr;
};


template<typename OutT, typename InT>
boost::shared_array<OutT> 
static_pointer_cast( const boost::shared_array<InT> & inSharedPtr )
{
  typedef SharedPtrCastHelper<boost::shared_array<InT> >  Helper;

  return boost::shared_array<OutT>( (OutT*)inSharedPtr.get(), 
                                    Helper(inSharedPtr) );
}

с этим вы можете сделать что-то вроде:

boost::shared_array<int>          intArrayPtr( new int[40] );  
boost::shared_array<unsigned int> uintArrayPtr;

uintArrayPtr = static_pointer_cast<unsigned int>( intArrayPtr );

Такое приведение, сгенерированное компилятором, невозможно.

Внутреннее устройство класса с константным параметром шаблона может существенно отличаться от класса без него из-за особенности специализации шаблона.

Более того, использование такой функции иногда является фоном для проверок во время компиляции, которые просто могут не разрешить создание экземпляра типа A<const T> для каждого случая, когда тип A<T> является правильным.