Есть ли способ использовать специализацию шаблона для отделения new от new[]?

std::unique_ptr в C++0x будет иметь специализацию для динамических массивов, как показано ниже. Однако создание соответствующего экземпляра будет задачей пользователя. На уровне языка невозможно отличить один указатель от другого.

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.

К сожалению нет. Оба возвращают один и тот же тип, 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);

С другой стороны, вы можете использовать определенную функцию make.

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

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

Конечно, это означает, что у вас есть соответствующая логика, но она инкапсулирована. Вы также можете добавить перегрузку, используя T для копирования объекта, переданного во вновь созданный указатель и т.д.

Наконец, это также можно сделать с перегрузками конструктора... дело не в том, чтобы вызывать new снаружи.

Я думаю, что реальное решение состоит в том, чтобы избавиться от вашего собственного класса автоуказатель и избавиться от использования массивов в стиле C. Я знаю, что это было сказано много-много раз раньше, но на самом деле больше нет смысла использовать массивы в стиле C. Почти все, что вы можете сделать с ними, можно сделать с помощью std::vector или boost::array. И оба они создают разные типы, так что вы можете перегрузить их.

Это невозможно, так как 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() );

Вы можете сделать свой класс более сложным, чтобы он мог вывести тип для удаления.

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

К сожалению, delete contents; не будет работать даже с 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)

К сожалению, это не работает с массивами динамического размера, поэтому я напишу еще один ответ.

Вторая попытка…

Довольно легко сделать класс интеллектуальных указателей умным в отношении массивов. Как вы и подозревали, вам не нужен флаг времени выполнения или аргумент для конструктора, если вы знаете, что это массив с самого начала. Единственная проблема заключается в том, что 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] );