C++ Cast boost:：共享_阵列<；char>；要增强：：共享_阵列<；常量字符>；

如何将

boost:：shared_array

转换为

boost:：shared_array

？

您不能

---

由于这两种类型都基于模板，因此对于编译器来说，这两种类型完全不同。

这样的编译器生成的强制转换是不可能的

由于模板专门化特性，具有const-qualified模板参数的类的内部可能与没有模板参数的类有很大的不同

---

此外，这种特性的使用有时是编译时检查的背景，可能仅仅不允许在

a

类型正确的情况下实例化

a

类型。如果您确实需要它，您可以创建一个自定义的智能指针类。可以找到相关提示。

其他答案都是正确的，你不能也不应该

此外，您确定要的是

boost:：shared_数组

，而不是

const boost:：shared_数组

实际上，这是可行的：

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

boost:：共享阵列acz；
boost:：shared_array&acz2=重新解释_cast（acz）；

但这不是一个好主意，只有当boost:：shared_数组和boost:：shared_数组具有相同的实现时才有效。模板可以部分专用化：

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

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

模板
结构实现{
国际货币联盟成员；
};
模板
struct two实现{
双m_f双成员；
};

在

two实现

和

two实现

之间进行重新解释转换是错误的

您可以使用get（）方法获取底层char*，它可以自动转换为const char*——但不要将其分配给另一个共享_数组，因为这样会删除两次数据。你需要什么就用什么

像这样：

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

boost:：共享_数组x（新int[13]）；
常量char*y=x.get（）；

由于

共享_数组

没有

添加_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) );

struct MagicDeleter{
MagicDeleter（boost:：shared_array ptr）：ptr（ptr）{}；
模板无效运算符（）（T*）{}
受保护的：
boost：：共享_阵列ptr；
};
...
boost：：共享阵列源ptr（一些值）；
boost:：shared_array new_ptr（orig_ptr.get（），MagicDeleter（orig_ptr））；

如果没有Kirill令人敬畏的回答，我不会想到这一点，但您可以有效地扩展boost的

静态指针\u cast

，它用于

共享\u ptr

处理

共享\u数组

：

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

模板
结构SharedPtrCastHelper
{
公众：
SharedPtrCastHelper（const OriginalType&ptr）：ptr（ptr）{}；
模板无效运算符（）（T*）{}
受保护的：
原始型ptr；
};
模板
boost：：共享数组
静态\u指针\u转换（常量boost:：共享\u数组和inSharedPtr）
{
typedef SharedPtrCastHelper助手；
return boost:：sharedptr.get（）中的共享_数组（（OutT*），
助手（共享PTR））；
}

这样，您就可以执行以下操作：

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

uintArrayPtr = static_pointer_cast<unsigned int>( intArrayPtr );

boost:：共享数组intArrayPtr（新int[40]）；
boost：：共享_阵列uintArrayPtr；
uintArrayPtr=静态指针投射（intArrayPtr）；

您认为为什么需要这样做？千万不要使用这样的重新解释，尤其是在这种情况下！一般来说，reinterpret_cast 99%是不可移植的。我知道这一点，并在我的帖子中承认这一点。所以请不要投反对票。这是一种语言功能，它可以工作，在1%的情况下甚至可能有用。@rmn：一种尺寸不适合所有人，我同意在这里这是一个坏主意，但千万不要说“永远”。不可能吗？然而，boost:：shared_ptr支持从派生类型到基类型（以及从非常量到常量）的隐式转换和各种类型的强制转换，它确实支持转换。但它不能进行类型转换。它确实支持类型转换，除非您完全是指其他内容。例如，

boost:：shared_ptr ptr（boost:：static_pointer_cast（base_shared_ptr））