Question

这是我的代码

在文件Burrito.cpp

中

#include "Burrito.h"
#include <iostream>

using namespace std;

Burrito::Burrito(){}

void Burrito::printCrap(){cout<< "something"<<endl;}

void Burrito::constante() const{cout<<"this aint gonna change"<<endl;}

Burrito::~Burrito(){cout<<"deconstructed"<<endl;}

文件Burrito.h中的

#ifndef BURRITO_H
#define BURRITO_H

class Burrito
{public:
        Burrito();
        void printCrap();
        void constante() const;
        ~Burrito();};

#endif // BURRITO_H

在主文件main.cpp中

#include <iostream>
#include "Burrito.h"
using namespace std;

int main()
{
    Burrito so;
    Burrito *sagar = &so;
    so.printCrap();
    sagar->printCrap();
  const Burrito constObject;
    constObject.constante();
    return 0;
}

我是初学者，这是我的查询。我试图了解desctructor，这个代码表现不错，只是它运行析构函数2次，所以这个程序的结果是这样的：

something
something
this aint gonna change
deconstructed
deconstructed

为什么要显示＆＃34; deconstrcuted＆＃34;两次？

Answer 1

您定义了类

的两个对象

#include <iostream>
#include "Burrito.h"
using namespace std;

int main()
{
    Burrito so;
    ^^^^^^^^^^^
    Burrito *sagar = &so;
    so.printCrap();
    sagar->printCrap();

  const Burrito constObject;
  ^^^^^^^^^^^^^^^^^^^^^^^^^^
    constObject.constante();
    return 0;
}

所以这两个对象都被破坏了。该程序中没有创建该类的其他对象。

指针sagar

的声明

Burrito *sagar = &so;

不会创建该类的对象。指针指向已创建的对象so。

许多指针可以同时引用同一个对象，但该对象只会被销毁一次。

如果你写了例如

Burrito *sagar = new Burrito;

然后

delete sagar;

然后在变量sagar的声明中创建了该类的另一个对象。然后使用运算符delete可以删除它。在这种情况下，将调用对象的析构函数。

Answer 2

您正在创建Burrito()的两个实例。

一个是Burrito so;
另一个是const Burrito constObject;

因此，当程序结束时它们会被破坏。

这就是你输出两次输出的原因。

Answer 3

你已经定义了两个Burrito实例 - so和constObject;因此，每个实例都会调用析构函数（注意：析构函数，而不是“解构函数”）。

为了清楚地说明正在创建，操作和销毁哪个对象，您可能希望修改您的类以包含name字段，仅用于演示目的：

Burrito.h

#ifndef BURRITO_H
#define BURRITO_H

class Burrito
{private: char *name;
 public:
        Burrito(char *nm);
        void printCrap();
        void constante() const;
        ~Burrito();};

#endif // BURRITO_H

Burrito.cpp

#include "Burrito.h"
#include <iostream>

using namespace std;

Burrito::Burrito(char *nm){ name = nm; cout << "constructed " << name << endl;}

void Burrito::printCrap(){cout<< name << ": something"<<endl;}

void Burrito::constante() const{cout<< name << ": this aint gonna change"<<endl;}

Burrito::~Burrito(){cout<<"destroyed " << name <<endl;}

的main.cpp

#include <iostream>
#include "Burrito.h"
using namespace std;

int main()
{
    Burrito so("so");
    Burrito *sagar = &so;
    so.printCrap();
    sagar->printCrap();
  const Burrito constObject("constObject");
    constObject.constante();
    return 0;
}

编译并运行上述结果：

constructed so
so: something
so: something
constructed constObject
constObject: this aint gonna change
destroyed constObject
destroyed so

祝你好运。

Answer 4

您在主要和constObject对象的末尾销毁了对象so，两者都被销毁，因此它们都会打印此消息。

析构函数的输出

4 个答案:

Burrito.h

Burrito.cpp

的main.cpp