有没有办法使用模板专门化来将 new 与 new[] 分开？

Question

我有一个自动指针类，在构造函数中我传递了一个指针。我希望能够在构造函数中将 new 与 new[] 分开，以便我可以在析构函数中正确调用 delete 或 delete[] 。这可以通过模板专门化来完成吗？我不想在构造函数中传递布尔值。

    template <typename T>
    class MyAutoPtr
    {
    public:
      MyAutoPtr(T* aPtr);
    };

// in use:
MyAutoPtr<int> ptr(new int);
MyAutoPtr<int> ptr2(new int[10]);

Answer 1

不幸的是，没有。两者都返回相同的类型，T*。考虑使用调用适当的重载构造函数的构建器函数：

template <typename T>
class MyAutoPtr
{
public:
    MyAutoPtr(T* aPtr, bool array = false);
};

template <typename T>
MyAutoPtr<T> make_ptr() {
    return MyAutoPtr<T>(new T(), false);
}

template <typename T>
MyAutoPtr<T> make_ptr(size_t size) {
    return MyAutoPtr<T>(new T[size], true);
}

现在您可以按如下方式实例化对象：

MyAutoPtr<int> ptr = make_ptr<int>();
MyAutoPtr<int> ptr2 = make_ptr<int>(10);

Answer 2

C++0x 中的 std::unique_ptr 将专门针对动态数组，如下所示。然而，实例化适当的实例将是用户的任务。在语言级别，没有办法区分一个指针和另一个指针。

template <class T>
class pointer
{
    T* p;
public:
    pointer(T* ptr = 0): p(ptr) {}
    ~pointer() { delete p; }
    //... rest of pointer interface
};

template <class T>
class pointer<T[]>
{
    T* p;
public:
    pointer(T* ptr = 0): p(ptr) {}
    ~pointer() { delete [] p; }
    //... rest of pointer and array interface
};

int main()
{
    pointer<int> single(new int);
    pointer<int[]> array(new int[10]);
}

此外，在一个类中加载如此多的任务可能也不是那么好。例如，boost 有 shared_ptr 和 shared_array。

Answer 3

另一方面，您可以使用特定的 make 函数。

template <class T>
MyAutoPtr<T> make();

template <class T>
MyAutoPtr<T> make(size_t n);

当然，这意味着您背后有适当的逻辑，但它是封装的。您还可以添加重载，采用 T 来复制传递给新创建的指针的对象等...

最后，它也可以通过构造函数的重载来完成...重点是不调用外面的new。

Answer 4

我认为真正的解决方案是摆脱你自己的自动指针类并摆脱 C 风格数组的使用。我知道这已经被说过很多很多次了，但是使用 C 风格的数组确实没有什么意义了。几乎所有你能用它们做的事情都可以使用 std::vector 或 boost::array 来完成。这两种类型都会创建不同的类型，因此您可以对它们进行重载。

Answer 5

这是不可能的，因为 new int[X] 产生一个指向数组初始元素的指针。它与int* 具有相同的类型。

常见的解决方案之一是使用删除器。删除。向您的类添加一个模板参数，以便您可以为指针传递自定义删除器。它将使您的课程更加通用。您可以像下面这样创建默认删除器：

struct default_deleter
{
    template<typename T>
    void operator()( T* aPtr ) { delete aPtr; }
};

对于数组，您可以传递自定义删除器：

struct array_deleter
{
    template<typename T>
    void operator()( T* aPtr ) { delete[] aPtr; }
};

最简单的实现是：

template <typename T, typename D>
class MyAutoPtr
{
public: 
    MyAutoPtr(T* aPtr, D deleter = default_deleter() ) : ptr_(aPtr), deleter_(deleter) {};
    ~MyAutoPtr() { deleter_(ptr_); }
protected:
    D deleter_;
    T* ptr_;
};

然后您可以按如下方式使用它：

MyAutoPtr<int, array_deleter> ptr2(new int[10], array_deleter() );

您可以使您的类更复杂，以便它可以推断出删除器的类型。

Answer 6

new[] 被专门定义为具有指针值，尽管数组到指针的隐式转换无论如何都会启动。

但我不认为你运气不好。毕竟，您的示例不是管理指向 int 的指针，而是管理指向 int[10] 的指针。所以理想的方法是

MyAutoPtr<int[10]> ptr2(new int[10]);

正如 Red-Nosed Unicorn 提到的，new int[10] 不会创建 C 风格的数组。如果您的编译器也符合 C 标准，则情况会如此，但 C++ 允许 C 样式数组的数量多于 C 中的 C 样式数组。无论如何，如果您这样询问，new 将为您创建一个 C 样式数组：

MyAutoPtr<int[10]> ptr2(new int [1] [10]);

不幸的是，deletecontents; 即使使用 int (*contents)[ 也无法工作10]；。编译器被允许做正确的事情：标准没有指定数组像 new 一样转换为指针，我相信我记得 GCC 替换了 delete[] 并发出警告。但这是未定义的行为。

因此，您将需要两个析构函数，一个用于调用 delete，一个用于调用 delete[]。由于您无法部分专门化一个函数，因此该功能需要一个部分专门化的帮助程序

template< class T > struct smartptr_dtor {
    void operator()( T *ptr ) { delete ptr; }
};

template< class T, size_t N > struct smartptr_dtor< T[N] > {
    void operator()( T (*ptr) [N] ) { delete [] ptr; }
};

template< class T >
void proper_delete( T *p ) {
    smartptr_dtor< T >()( p );
}

，出于某种原因，我只是让自己接受；v）

不幸的是，这不适用于动态大小的数组，所以我要写下另一个答案。

Answer 7

第二次尝试……

让智能指针类对数组变得智能是很容易的。正如您所怀疑的，如果您知道它是一个数组，则不需要构造函数的运行时标志或参数。唯一的问题是 new 和 new[] 具有相同的返回类型，因此它们无法将此信息传递给智能指针类。

template< class T, bool is_array = false >
struct smartptr {
    T *storage;

    smartptr( T *in_st ) : storage( in_st ) {}

    ~smartptr() {
        if ( is_array ) delete [] storage; // one of these
        else delete storage; // is dead code, optimized out
    }
};

smartptr< int > sp( new int );
smartptr< int, true > sp2( new int[5] );

bool 标志的替代方法是重载 T[] 的含义，就像访问者提到 std::unique_ptr 在 C++0x 中所做的那样。

template< class T >
struct smartptr {
    T *storage;

    smartptr( T *in_st ) : storage( in_st ) {}

    ~smartptr() { delete storage; }
};

template< class T > // partial specialization
struct smartptr< T [] > {
    T *storage; // "T[]" has nothing to do with storage or anything else

    smartptr( T *in_st ) : storage( in_st ) {}

    ~smartptr() { delete [] storage; }
};

smartptr< int > sp( new int );
smartptr< int[] > sp2( new int[5] );