C++ 构造函数和析构函数是如何工作的？ class-Foo{ 公众： Foo（）{ 库特 构造了C-a 构造了C-b 构造了C-C 因为你离开了这个范围，所以D-c被分解了 C-对象Foo是动态分配的，并由p指向，但由于它是动态分配的，并且从未被删除，所以它从未被破坏 D-b被破坏了 D-a被破坏了 构造了C-a 构造了C-b 构造了C-C 因为你离开了这个范围，所以D-c被分解了 C-对象Foo是动态分配的，并由p指向，但由于它是动态分配的，并且从未被删除，所以它从未被破坏 D-b被破坏了 D-a被破坏了

C.D.的订单如下：

C-构造A

C-构造B

C-构造C

D-自毁C

C-构造p（在func中）

D-自毁B

D-破坏A

---

//memleak for p（在func中）

C D的顺序如下：

C-构造A

C-构造B

C-构造C

D-自毁C

C-构造p（在func中）

D-自毁B

D-破坏A

//memleak for p（在func中）

当包含

func（）；

调用时，所采取的步骤是：

class Foo{
public:
    Foo(){
        cout <<"C ";
    }
    ~Foo(){
        cout <<"D ";
    }
};

void func(){
    Foo* p = new Foo;
    p = NULL;
}

int main(){
    Foo a;
    for (int i=0; i<1; i++){
        Foo b;
        if (true){
            Foo c;
        }
        func();
    }
    return 0;
}

请注意，在func（）中创建的Foo对象从未被分解，这意味着您有内存泄漏。

当包含

func（）；

调用时，所采取的步骤是：

class Foo{
public:
    Foo(){
        cout <<"C ";
    }
    ~Foo(){
        cout <<"D ";
    }
};

void func(){
    Foo* p = new Foo;
    p = NULL;
}

int main(){
    Foo a;
    for (int i=0; i<1; i++){
        Foo b;
        if (true){
            Foo c;
        }
        func();
    }
    return 0;
}

---

请注意，在func（）中创建的Foo对象从未被分解，这意味着您存在内存泄漏。

对象

a

的范围是函数main的外部代码块的范围。它是创建的第一个对象，也是删除的最后一个对象

Foo a; -> C

Foo b; -> C

Foo c; -> C

Left the scope of Foo c -> D

func(); call ->
    new Foo; -> C

Finished func() call, left the scope of Foo b -> D

Left the scope of Foo a -> D

然后，在只有一次迭代的for循环中，创建了对象

b

，该对象在循环的第一次迭代后被删除

int main(){
    Foo a;
    // ...
    return 0;
}

C C C D C D D
|           |
a           a

创建并删除了对象

c

    if (true){
        Foo c;
    }

然后调用函数

func

C C C D C D D
| | | |   | |
a b c c   b a

在函数内部，使用new运算符创建了一个未命名对象，并由指针

p

指向

func();

未删除此对象，因为未为此对象调用运算符delete。因此存在内存泄漏

---

仅此而已。

对象的范围

a

是函数main的外部代码块的范围。它是创建的第一个对象和删除的最后一个对象

Foo a; -> C

Foo b; -> C

Foo c; -> C

Left the scope of Foo c -> D

func(); call ->
    new Foo; -> C

Finished func() call, left the scope of Foo b -> D

Left the scope of Foo a -> D

然后，在只有一次迭代的for循环中，创建了对象

b

，该对象在循环的第一次迭代后被删除

int main(){
    Foo a;
    // ...
    return 0;
}

C C C D C D D
|           |
a           a

创建并删除了对象

c

    if (true){
        Foo c;
    }

然后调用函数

func

C C C D C D D
| | | |   | |
a b c c   b a

在函数内部，使用new运算符创建了一个未命名对象，并由指针

p

指向

func();

未删除此对象，因为未为此对象调用运算符delete。因此存在内存泄漏

---

仅此而已。

（int i＝0；通过调试器将其通过……<代码> p= null；< /COD>实际上不会破坏对象。<代码>新的FoO 对象泄漏。这行应该读取<代码>删除p；<代码>。您似乎对析构函数做了什么以及对象生命周期如何工作感到困惑。这是C++的最基本的东西，最好的掩饰。如果您添加一些调试消息，您会注意到CTOR用于abcp，DTOR用于cba，顺序是退出scope.P leaks（int i＝0；通过调试器将其通过……<代码> p= null；< /COD>实际上不会破坏对象。<代码>新的FoO 对象泄漏。这行应该读取<代码>删除p；<代码>。您似乎对析构函数做了什么以及对象生命周期如何工作感到困惑。这是C++的最基本的东西，最好的掩饰。如果您添加一些调试消息，您会注意到CTOR用于abcp，DTOR用于cba，顺序是退出scope.P。