Класс контейнера указателя, который нельзя скопировать по значению

Чтобы ответить на ваш первый вопрос, лучшая гарантия того, что это правильно, - это реализовать вокруг него тестовую оснастку, чтобы выполнить некоторую простую задачу, и убедиться, что вы получаете ожидаемое поведение. Для меня это гораздо больше утешения, чем то, что код правильный, чем мнение какого-то случайного человека, читающего его.

Что касается вашего второго вопроса, вы работаете с Удалить, выдающим ошибку утверждения, устанавливая указатель на некоторое значение маркера после его удаления в первый раз. Что-то вроде:

if (pointer) {
    delete pointer;
    pointer = NULL;
} else {
    error("Attempted to free already freed pointer.");
}

Проблема, с которой вы здесь столкнетесь, заключается в том, что ваш перегруженный оператор -> возвращает значение указателя, а это означает, что любой, кому вы его вернете, также может вызвать Удалить, в результате чего проверка, которую я предлагаю выше, не сработает. Например:

simple_ptr<int> myPtr = someIntPointer;
...
delete myPtr.operator->(); /* poof goes your pointered memory region */

Я мог бы порекомендовать вам не полагаться на перегрузку оператор->, а просто потребовать, чтобы те, кто использует этот класс, вызывали метод, который разыменовывает указатель внутри, прежде чем передавать это значение обратно пользователю.

Надеюсь это поможет.

Is this implementation correct? I have made copy constructor as private ...

Вы можете сделать то же самое для оператора присваивания:

simple_ptr& operator=(const simple_ptr<T>& t);

Также может быть полезна константная версия оператора разыменования, и умные указатели обычно определяют и другой тип оператора разыменования:

const T* operator->() const { return pointer; }
const T& operator*() const { return *pointer; }
T& operator*() { return *pointer; }

If by chance the pointer is deleted, delete operation on the destructor will throw assertion error. How can I workaround this?

Вы имеете в виду, если я сделаю это:

//create instance
Car* car = new Car;
//assign to smart ptr
simple_ptr<Car> ptr(car);
//explicit delete
delete car;
//... assertion when ptr is destroyed ...

Способ (я не знаю, является ли это способ хорошо), чтобы предотвратить это, состоит в том, чтобы объявить конструктор и / или деструктор и / или оператор удаления класса T как private и сказать, что simple_ptr является friend из класс T (так что только класс simple_ptr может создавать и / или уничтожать и / или удалять экземпляры T).

Marking the new operator as private in T class seems to be impossible as I have to modify all the classes which will be used with simple_ptr

Да, это правда: чтобы сделать мое предложение непосредственно выше, вам нужно будет изменить определения классов.

Если ваш вопрос: «как я могу сделать невозможным двойное удаление, не изменяя определения классов?» тогда я думаю, что ответы таковы:

• Вы не можете: нужно быть осторожным в коде приложения (которое использует эти классы)
• Вы можете: предоставить свой собственный менеджер кучи, то есть вашу собственную реализацию глобального оператора new и глобального оператора delete, и в вашем коде smart_ptr опросить ваш менеджер кучи, чтобы узнать, выделено ли это воплощение этого указателя, прежде чем вы его удалите.

Иногда я видел использование простых макросов DISABLE_COPY:

#define DISABLE_COPY(Class) \
        Class(const Class &); \
        Class &operator=(const Class &);

Таким образом, принято определять конструктор копирования и оператор присваивания как частные для вашей задачи.

Вы сделали boost :: scoped_ptr

Также прочтите комментарий j_random_hacker.

Пожалуйста, используйте boost :: scoped_ptr <>, как предложил Мартин Йорк, потому что он:

• Делает именно то, что вы хотите (это не копируемый указатель)
• Не имеет накладных расходов выше, чем у стандартного указателя C
• Был тщательно разработан сверхразумными мастерами C++, чтобы убедиться, что он ведет себя так, как ожидалось.

Хотя я не вижу никаких проблем с вашей реализацией (после применения изменений, предложенных ChrisW), у C++ много темных углов, и я не удивлюсь, если есть какой-то неясный угловой случай, который вы, я и другие здесь не смогли место.

У вас есть два варианта:

1. boost::scoped_ptr уже подробно описан j_random_hacker, потому что он не копируемый (не разделяет права собственности, как shared_ptr) и не перемещается (не передает право собственности, как auto_ptr. Auto_ptr имеет конструктор копирования, но он не копирует. Он перемещает оригинал указатель на * this). boost::scoped_ptr - это именно то, что вам нужно.
2. const auto_ptr не допускает передачу права собственности. И возьмите свой параметр по ссылке на const (auto_ptr<T> const&). Если вместо этого автор функции принимает значение по значению, он все равно не будет работать, если вы попытаетесь передать const auto_ptr, потому что его конструктору копирования требуется неконстантный auto_ptr.

До C++ 1x, boost :: scoped_ptr - лучший выбор для ваших нужд или const auto_ptr, если вам нужно использовать официальные стандартные вещи (прочтите это). В C++ 1x вы можете использовать std::unique_ptr как лучшую альтернативу auto_ptr, потому что вам нужно явно указать, когда вы хотите передать право собственности. Попытка скопировать его приведет к ошибке времени компиляции. unique_ptr немного подробно описан в ответе это.

Вы должны использовать boost :: scoped_ptr <>, как уже упоминалось.

В общем случае, если вам нужно сделать класс не копируемым, вы должны унаследовать от boost :: noncopyable, т.е.

#include <boost/utility.hpp>

class myclass : boost::noncopyable
{
    ...
};

Это делает всю работу по предотвращению копирования и хорошо самодокументируется.