c++ - 这些实现会导致内存泄漏吗？

Question

以下情况会导致内存泄漏吗？如果是，我该如何解决这个问题？我应该在类中使用指针Base（即Structure* var）并在析构函数中删除它吗？

如果情况 2 不会导致内存泄漏，会发生什么Structure(0,0)？它立即被创建并被销毁还是发生了其他事情？

情况1 ：

struct Structure
{
    int a;
    int b;
    Structure() { a=1; b=2; }
    Structure(int num1, int num2) : a(num1), b(num2){}
};

class Base
{
    private:
        Structure var;
    public: 
        Base(Structure structure)
        {
            var = structure;
        }
};

class Derived : public Base
{
    public:
        Derived(bool boolean) : Base(boolean ? *(new Structure(0,0)) : *(new Structure(10,10))){}
};

int main()
{
    Derived derived(true);
}

案例2：

struct Structure
{
    int a;
    int b;
    Structure() { a=1; b=2; }
    Structure(int num1, int num2) : a(num1), b(num2){}
};

class Base
{
    private:
        Structure var;
    public: 
        Base(Structure structure)
        {
            var = structure;
        }
};

class Derived : public Base
{
    public:
        Derived(bool boolean) : Base(boolean ? Structure(0,0) : Structure(10,10)){}
};

int main()
{
    Derived derived(true);
}

Answer 1

案例 1 泄漏是因为您new没有相应delete的 .

案例 2 不会泄漏，因为您没有new.

Answer 2

第一种情况非常糟糕：

  Derived(bool boolean) : Base(boolean ? *(new Structure(0,0)) : *(new Structure(10,10))){}
                                           ^^^^                    ^^^

您正在动态分配 aStructure但您没有保留指针，因此您无法调用delete它们，因此您将泄漏内存。第二种情况没有这个问题。

Answer 3

第一种选择将导致内存泄漏，无论您是传递true还是传递false给Derived. 正好一个会在堆上分配，然后被赋值时Structure的默认复制构造函数复制Structure

 var = structure;

被执行。

如果你：

• 按照问题中的建议用指针替换内部var变量类型
• delete析构函数中的指针
• 实现一个复制构造函数来处理分配Base复制varnew

你不应该有任何问题。

struct Structure {
    int a;
    int b;
    Structure() { a=1; b=2; }
    Structure(int num1, int num2) : a(num1), b(num2){}
};

class Base {
    private:
        Structure *var;
    public: 
    Base(Structure *structure) {
        var = structure;
    }
    Base(const Base &b) {
        var = new Structure(*b.var);
    }
    virtual ~Base(){
        delete var;
        var = 0;
    }
};