內存泄漏C ++指針

Question

int main()
{
    A* x = new B(10, 20);
    x->opt1();
    delete x;
    return 0;
}

int main()
{
    B x(10, 20);
    return 0;
}

因此，第一個有內存泄漏，我知道因為x是指向B對象的A對象。 如果A不是指針，它是否還會發生內存泄漏？

為什么第二個功能沒有內存泄漏？ 我們不需要刪除x嗎？

class A
{
    private:
        int* a;
    public:
        A(int size) {
            a = new int[size];
        }
        ~A() {
            if (a) {
                delete [] a;
            }
        };
        virtual void opt1() {
            cout << "A::opt1()" << endl;
        }
};

class B : public A
{
    private:
        float* b;
    public:
        B(int size1, int size2) : A(size1) {
            b = new float[size2];
        }
        ~B() {
            if(b){
                delete [] b;
            }
        }
        virtual void opt1() {
            cout << "B::opt1()" << endl;
        }
};

Answer 1

第一個內存泄漏，我知道因為x是指向B對象的A對象。

不，如果A和B具有明確定義的繼承關系，則不會發生內存泄漏。 如：

class A {
public:
    virtual ~A() {}
};

class B : public A {
};

為什么第二個功能沒有內存泄漏？

因為x是在堆棧上分配的，所以不需要，也不能在其上調用delete 。 x將被自動銷毀。

我們不需要刪除x嗎？

僅由new創建的對象需要delete 。

編輯

對於您的A和B代碼，第一種情況將導致內存泄漏，因為A （基類）的析構函數不是virtual 。 對於

A* x = new B(10, 20);
delete x;

僅會調用A的析構函數，而不會調用B的析構函數，這意味着B float* b不會被釋放。

如果要以這種方式使用它們（例如，通過指向基類的指針刪除派生類的實例），這是一個壞主意。

請參閱何時使用虛擬析構函數？

Answer 2

在第二個實例中，雖然該項目的構造函數被調用，但new未被顯式調用。 但是變量會自動超出范圍，因此只要正確編寫了析構函數以抵消對象內的任何內部分配，就可以自動調用析構函數以防止發生任何形式的泄漏。

我認為第一個示例不會造成內存泄漏，但是也許基於類的某些優點會導致問題。