Очистка объекта C++

Вместо этого я бы позволил конструктору вызвать мою функцию:

class Foo
{
private:
    int n_;
    std::string str_;
public:
    Foo()
    {
        Reset();
    }

    void Reset()
    {
        n_ = 1234;
        str_ = "Hello, world!";
    }
};

Да, вы без необходимости сначала инициализируете строку как пустую строку, а затем выполняете присваивание, но это намного яснее.

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

рассмотрите возможность использования размещения new:

void Empty() {
    this->~Foo();
    new (this) Foo();
}

Ваш код вызывает operator =, что может привести к всевозможным побочным эффектам.

РЕДАКТИРОВАТЬ в ответ на комментарии. - Этот код определенно четко определен, стандарт явно разрешает это. Я отправлю этот абзац позже, если найду время. Про delete - конечно. Я имел в виду ~Foo(), это была оплошность. И да, Роб тоже прав; разрушение объекта здесь действительно необходимо для вызова деструктора строки.

Да, это неэффективно с точки зрения производительности (создание другого объекта foo вместо работы на месте), и вас укусит, если вы выделите память в конструкторе с неприятной утечкой памяти.

Чтобы сделать его более безопасным с точки зрения памяти, нужно вызвать this-> delete и this = new foo (), но это будет МЕДЛЕННО.

если вы хотите быть сверхбыстрым, создайте статическое пустое поле объекта и запишите его в Reset.

если вы хотите просто быстро назначать свойства одно за другим.

если вы хотите сохранить разумный стиль без дублирования, вызовите Reset из Ctor, как предлагал Атес Горал, но вы потеряете более быструю конструкцию с параметрами по умолчанию.

Потенциальные проблемы? Откуда вы знаете, что * это действительно Фу?

Есть нечто даже более распространенное, чем то, что вы предложили. используя своп.

Обычно вы делаете что-то вроде этого:

T().swap(*this);

поскольку многие стандартные контейнеры (все контейнеры STL?) имеют метод постоянной временной замены, это хороший и простой способ очистить контейнер и убедиться, что его хранилище освобождено.

Точно так же это хороший способ «сжать до размеров контейнера», но с использованием конструктора копирования вместо конструктора по умолчанию.

То, что вы делаете с этим методом Empty, по сути то же самое, что вручную присваивать вновь созданный объект переменной (то, что делает функция Empty).

Лично я бы удалил метод Empty и заменил все его использования следующим образом:

// let's say, that you have variables foo and pfoo - they are properly initialized.
Foo foo, *pfoo;

// replace line "foo.Empty()" with:
foo = Foo();

// replace line "pfoo->Empty()" with:
delete pfoo;
pfoo = new Foo();
// or
*pfoo = Foo();

Я действительно не вижу преимуществ в использовании этого метода Empty. Он скрывает, что на самом деле происходит с объектом, который он называется, имя тоже не лучший выбор.

Если вызывающему действительно нужен чистый объект - у него не возникнет проблем с его построением.

This seems to be better than duplicating code in the constructor, but I wondered if *this = Foo() is a common approach when wanting to clear an object?

Очистка объекта - не такая уж обычная вещь: чаще всего либо объект (возможно, даже неизменяемый объект) создается и содержит реальные данные, либо не создается.

Самым распространенным типом сброса находятся будут контейнеры ... но вы бы сейчас не писали свои собственные классы контейнеров, не так ли?

Are there any problems with this waiting to bite me on the backside?

Да:

• Если это на самом деле не Foo, а DerivedFoo
• Если оператор присваивания Foo не существует или он содержит ошибки (например, если он не определен и оператор по умолчанию не подходит, например, из-за того, что член данных является голым указателем).

Are there any other better ways to achieve this sort of thing?

Да, возможно, бесплатная функция была бы лучше (позволила бы избежать обеих вышеуказанных проблем):

template<class T> void reconstruct(T* p)
{
    p->~T();
    new (p) T();
}

Это может быть потенциальным источником утечки памяти, если у вас есть динамически выделяемая память в конструкторе.

Вот как я это делаю:

class Foo {
private:
    int n_;
    std::string str_;
public:
    Foo() : n_(1234), str_("Hello, world!")
    {
    }

    void Empty()
    {
        Foo f;
        swap(f);
    }

    void swap(Foo & other) {
        std::swap(n_, other.n_);
        swap(str_, other.str_);
    }
};

void swap(Foo & one, Foo & other) {
    one.swap(other);
}

Поместите функцию подкачки в то же пространство имен, что и класс Foo. Поиск, зависящий от аргумента, находит его, когда пользователи выполняют вызов, чтобы поменять местами два Foo. Вы также можете реализовать operator=, используя функцию подкачки.