Cast boost :: shared_array <char> to boost :: shared_array <const char>

Question

Как я могу нарисовать boost::shared_array<char> до boost::shared_array<const char>?

Answer 1

Поскольку 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)); 

Answer 2

Вы не можете.

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

Answer 3

Такое формирование с использованием компилятора не может быть возможным.

Внутренние элементы класса с параметром шаблона с параметром const могут сильно отличаться от класса без одного из-за функции специализированного шаблона.

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

Answer 4

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

Answer 5

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

Кроме того, вы уверены, что хотите 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); 

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

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

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

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

Answer 6

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

так:

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

Answer 7

Я бы не подумал об этом, не удивительный ответ Кирилла, но вы можете эффективно продлить static_pointer_cast форсирования, который используется для shared_ptr s для работы на shared_array с таким образом:

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