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

Question

How can I cast a boost::shared_array<char> to boost::shared_array<const char>?

Answer 1

You can't.

As both types are based on a template, both types are completely different for the compiler.

Answer 2

Such compiler-generated casting can not be possible.

The internals of the class with const-qualified template parameter may differ dramatically from the class without one, due to template specialization feature.

Moreover, the use of such feature is sometimes a background for compile-time checks that merely may not allow instantiation of A<const T> type for every case where A<T> type is correct.

Answer 3

I think you can't. In case you really need it though, you can create a custom smart-pointer class. Hints for that can be found here.

Answer 4

The other answers are correct, you can't and you shouldn't.

Besides, are you sure you want a boost::shared_array<const char> and not a const boost::shared_array<char>?

Practically, this works:

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

BUT it is not a good idea and only works if boost::shared_array and boost::shared_array have the same implementation. Templates can be partially specialized:

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

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

Doing a reinterpret cast between TwoImplementations<int> and TwoImplementations<const int> is just wrong.

Answer 5

You could use the get() method to get the underlying char*, which is auto convertible to a const char* - but don't assign it to another shared_array because then you'll have the data deleted twice. Just use it as you need it.

like this:

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

Answer 6

Since shared_array has no add_ref method you could emulate it as follows:

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