Будет ли приведенный ниже код вызывать утечку памяти в C++

Все, что вы «новое», необходимо удалить, иначе вы вызовете утечку памяти. Итак, эти две строки:

psomeclass = new someclass();
pint = new int(); 

Вызовет утечку памяти, потому что вам нужно сделать:

delete pint;
delete psomeclass;

В блоке finally, чтобы избежать их утечки.

Также эта строка:

base temp = base();

Не нужно. Вам просто нужно сделать:

base temp;

Добавлять «= base ()» не нужно.

Да, этот код приведет к утечке памяти. Блоки памяти, выделенные с помощью «нового», не освобождаются при возникновении исключения. Это часть мотивации RAII.

Чтобы избежать утечки памяти, попробуйте что-то вроде этого:

psomeclass = NULL;
pint = NULL;
/* So on for any pointers you allocate */

try {
    objsomeclass = someclass();
    psomeclass = new someclass();
    pint = new int(); 
    throw "constructor failed";
    a = 43;
 }
 catch (...)
 {
     delete psomeclass;
     delete pint;
     throw;
 }

Если вы добавляете конструктор, вы должны очистить все, что было до вызова throw. Если вы используете наследование или добавление деструктора, вам действительно не следует этого делать. Странное поведение (нет моего стандартного под рукой, но он может быть неопределенным?).

Обе новинки будут протекать.

Назначьте адрес созданных объектов кучи интеллектуальным указателям названный, чтобы он был удален внутри деструктора интеллектуальных указателей, вызываемого при возникновении исключения - (RAII).

class base {
    int a;
    boost::shared_ptr<int> pint;
    someclass objsomeclass;
    boost::shared_ptr<someclass> psomeclass;

    base() :
        objsomeclass( someclass() ),
        boost::shared_ptr<someclass> psomeclass( new someclass() ),
        boost::shared_ptr<int> pint( new int() )
    {
        throw "constructor failed";
        a = 43;
    }
};

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

int main(){
    base *temp = new base();
}

Для обычного выделения памяти с использованием (не plcaement) new память, выделенная оператором new, освобождается автоматически, если конструктор генерирует исключение. Что касается того, зачем беспокоиться об освобождении отдельных членов (в ответ на комментарии к ответу Майка Б.), автоматическое освобождение применяется только тогда, когда в конструкторе нового объекта создается исключение, а не в других случаях. Кроме того, освобождаемая память - это память, выделенная для членов объекта, а не любая память, которую вы могли выделить, скажем, внутри конструктора. т.е. он освободит память для переменных-членов а, пинта, objsomeclass и псомекласс, но не память, выделенную из новый someclass () и новый int ().

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

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

Если вы используете что-то вроде шаблона Boost scoped_ptr <>, ваш класс мог бы выглядеть примерно так:

class base{
    int a;
    scoped_ptr<int> pint;
    someclass objsomeclass;
    scoped_ptr<someclass> psomeclass;
    base() : 
       pint( new int),
       objsomeclass( someclass()),
       psomeclass( new someclass())

    {
        throw "constructor failed";
        a = 43;
    }
}

И у вас не будет утечек памяти (и dtor по умолчанию также очистит распределение динамической памяти).

Подводя итог (и, надеюсь, это также ответит на вопрос о

base* temp = new base();

утверждение):

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

1. деструктор для создаваемого объекта будет вызван нет.
2. деструкторы для объектов-членов, содержащихся в этом классе объекта, будут вызываться
3. память для создаваемого объекта будет освобождена.

Это означает, что если ваш объект владеет ресурсами, у вас есть 2 доступных метода для очистки тех ресурсов, которые могли быть уже получены, когда конструктор выбрасывает:

1. поймать исключение, освободить ресурсы, а затем повторно выбросить. Это может быть трудно исправить, и это может стать проблемой при обслуживании.
2. использовать объекты для управления временем жизни ресурсов (RAII) и использовать эти объекты в качестве членов. Когда конструктор вашего объекта генерирует исключение, у объектов-членов будут вызываться деструкторы, и у них будет возможность освободить ресурс, за время жизни которого они несут ответственность.

вам нужно удалить psomeclass ... Нет необходимости очищать целое число ...

RWendi

Я считаю, что главный ответ неверен и все равно будет утечка памяти. Деструктор для членов класса будет вызван нет, если конструктор выдает исключение (потому что он никогда не завершал свою инициализацию, и, возможно, некоторые члены никогда не достигли своих вызовов конструктора). Их деструкторы вызываются только во время вызова деструктора класса. Это имеет смысл.

Эта простая программа демонстрирует это.

#include <stdio.h>


class A
{
    int x;

public:
    A(int x) : x(x) { printf("A constructor [%d]\n", x); }
    ~A() { printf("A destructor [%d]\n", x); }
};


class B
{
    A a1;
    A a2;

public:
    B()
    :   a1(3),
        a2(5)
    {
        printf("B constructor\n");
        throw "failed";
    }
    ~B() { printf("B destructor\n"); }
};


int main()
{
    B b;

    return 0;
}

Со следующим выводом (с использованием g ++ 4.5.2):

A constructor [3]
A constructor [5]
B constructor
terminate called after throwing an instance of 'char const*'
Aborted

Если ваш конструктор частично выйдет из строя, вы обязаны с этим разобраться. Хуже того, исключение может быть выброшено из конструктора вашего базового класса! Способ справиться с этими случаями - использовать «блок попытки функции» (но даже в этом случае вы должны тщательно кодировать уничтожение вашего частично инициализированного объекта).

Тогда правильный подход к вашей проблеме будет примерно таким:

#include <stdio.h>


class A
{
    int x;

public:
    A(int x) : x(x) { printf("A constructor [%d]\n", x); }
    ~A() { printf("A destructor [%d]\n", x); }
};


class B
{
    A * a1;
    A * a2;

public:
    B()
    try  // <--- Notice this change
    :   a1(NULL),
        a2(NULL)
    {
        printf("B constructor\n");
        a1 = new A(3);
        throw "fail";
        a2 = new A(5);
    }
    catch ( ... ) {   // <--- Notice this change
        printf("B Cleanup\n");
        delete a2;  // It's ok if it's NULL.
        delete a1;  // It's ok if it's NULL.
    }

    ~B() { printf("B destructor\n"); }
};


int main()
{
    B b;

    return 0;
}

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

B constructor
A constructor [3]
B Cleanup
A destructor [3]
terminate called after throwing an instance of 'char const*'
Aborted

Вы все еще можете решить эту проблему с помощью умных общих указателей, если хотите, с дополнительным копированием. Написание конструктора, подобного этому:

class C
{
    std::shared_ptr<someclass> a1;
    std::shared_ptr<someclass> a2;

public:
    C()
    {
        std::shared_ptr<someclass> new_a1(new someclass());
        std::shared_ptr<someclass> new_a2(new someclass());

        // You will reach here only if both allocations succeeded. Exception will free them both since they were allocated as automatic variables on the stack.
        a1 = new_a1;
        a2 = new_a2;
    }
}

Удачи, Цви.