Cast boost::shared_array<char> to boost::shared_array<const char>
-
12-09-2019 - |
Question
How can I cast a boost::shared_array<char>
to boost::shared_array<const char>
?
Solution
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) );
OTHER TIPS
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.
You can't.
As both types are based on a template, both types are completely different for the compiler.
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.
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();
I wouldn't have thought of this without Kirill's awesome answer, but you can effectively extend boost's static_pointer_cast
that is used for shared_ptr
s to work on shared_array
s as so:
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) );
}
with that you can then do something like:
boost::shared_array<int> intArrayPtr( new int[40] );
boost::shared_array<unsigned int> uintArrayPtr;
uintArrayPtr = static_pointer_cast<unsigned int>( intArrayPtr );
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.