C++ 父类析构函数是否删除具有外部启动元素的子类？

太空船

#include <iostream>
#include <string>
#include <math.h>
#include <vector>


class Position {

public:
    Position (std::string Name, double x, double y, double z);

private:
    std::string Name;
    double x, y, z; //Coordinates on a 3D map


};

class Flight {

public:
    Flight (Position *Start, Position *End);
    ~Flight();

private:
    Position *Start;
    Position *End;

};


class Spaceship {

public:
    Spaceship (std::string Name, Flight *flightPlan);
    ~Spaceship();

private:
    std::string Name;
    Flight *flightPlan;

};

class Universe {

public:
    Universe ();
    ~Universe ();

    void addSpaceship (Spaceship *Spaceship);

    private:
        std::vector <Spaceship*> *Spaceships; // A vector of Spaceship pointers
        std::vector <Spaceship*>::iterator start, end;
        int numberOfSpaceships;

};

#包括
#包括
#包括
#包括
阶级地位{
公众：
位置（标准：：字符串名称，双x，双y，双z）；
私人：
std：：字符串名；
双x，y，z；//三维地图上的坐标
};
班机{
公众：
飞行（位置*开始，位置*结束）；
~Flight（）；
私人：
位置*开始；
位置*结束；
};
二级宇宙飞船{
公众：
宇宙飞船（标准：：字符串名称，飞行*飞行计划）；
~宇宙飞船（）；
私人：
std：：字符串名；
飞行计划；
};
阶级宇宙{
公众：
宇宙（）；
~Universe（）；
太空船（太空船*太空船）；
私人：
std:：vector*Spaceships；//一个宇宙飞船指针的向量
std:：vector:：迭代器开始、结束；
国际宇宙飞船；
};

太空船

#include "Spaceship.h"

Position::Position (std::string Name, double x, double y, double z) {
    this->Name = Name;
    this->x = x;
    this->y = y;
    this->z = z;
}


 //------------------------------------------------------------

Flight::Flight (Position *Start, Position *End) {
    this->Start = Start;
    this->End = End;
}


Flight::~Flight () {
    delete this->Start;
    delete this->End;
}



//--------------------------------------------------------------

Spaceship::Spaceship (std::string Name, Flight *flightPlan) {
    this->Name = Name;
    this->flightPlan = flightPlan;
}

Spaceship::~Spaceship () {
    delete this->flightPlan;
}

void Spaceship::printFlightPlan () {
    std::cout << "Spaceship name: " << this->Name << std::endl;
    this->flightPlan->printFlightPlan();
}

//---------------------------------------------------------------

Universe::Universe () {
    this->Spaceships = new std::vector <Spaceship*>();
    this->start = this->Spaceships->begin();
    this->end = this->Spaceships->end();

    this->numberOfSpaceships = Spaceships->size();
}

Universe::~Universe() {
    delete this->Spaceships;

}

void Universe::addSpaceship(Spaceship *Spaceship) {
    this->Spaceships->push_back(Spaceship);
    this->start = this->Spaceships->begin();
    this->end = this->Spaceships->end();
}


int main (void) {   

    Position *Start = new Position("Home", 45.566, 34.5677, -12.4565);
    Position *End = new Position ("Far Far Away", 67.4564, -56.6765, 23.4565);

    Flight *virginFlight = new Flight(Start, End);

    Spaceship *sp1 = new Spaceship("Virgin Mary", virginFlight);
    Spaceship *sp2 = new Spaceship("Something else", virginFlight);


    Universe *alpha = new Universe();

    alpha->addSpaceship(sp1);
    alpha->addSpaceship(sp2);


    delete alpha;

    return 0;
}

#包括“Spaceship.h”
位置：：位置（标准：：字符串名称，双x，双y，双z）{
此->名称=名称；
这个->x=x；
这->y=y；
这个->z=z；
}
//------------------------------------------------------------
航班：航班（位置*开始，位置*结束）{
这个->开始=开始；
这->结束=结束；
}
航班：：~航班（）{
删除此->开始；
删除此->结束；
}
//--------------------------------------------------------------
Spaceship:：Spaceship（标准：：字符串名称，Flight*flightPlan）{
此->名称=名称；
此->飞行计划=飞行计划；
}
太空船：：~太空船（）{
删除此->飞行计划；
}
作废宇宙飞船：：printFlightPlan（）{
std:：cout printFlightPlan（）；
}
//---------------------------------------------------------------
宇宙：：宇宙（）{
这->太空船=新的std:：vector（）；
这->开始=这->宇宙飞船->开始（）；
这->结束=这->宇宙飞船->结束（）；
这->numberOfSpaceships=宇宙飞船->大小（）；
}
宇宙：：~Universe（）{
删除这个->太空船；
}
虚空宇宙：：添加宇宙飞船（宇宙飞船*宇宙飞船）{
这->宇宙飞船->推回（宇宙飞船）；
这->开始=这->宇宙飞船->开始（）；
这->结束=这->宇宙飞船->结束（）；
}
int main（void）{
位置*开始=新位置（“起始”，45.566，34.5677，-12.4565）；
位置*结束=新位置（“很远”，67.4564，-56.6765，23.4565）；
航班*飞行中=新航班（开始、结束）；
太空船*sp1=新太空船（“维珍玛丽”，维珍飞行中）；
太空船*sp2=新太空船（“其他东西”，飞行中）；
宇宙*alpha=新宇宙（）；
阿尔法->太空船（sp1）；
阿尔法宇宙飞船（sp2）；
删除alpha；
返回0；
}

好的，这应该是我的代码最干净的版本。它只有构造函数和析构函数。如果我遗漏了一些变量/函数，请假设它们存在。这可以编译并运行得很好。我唯一的问题是内存泄漏

---

Valgrind报告allocs>删除至少为2倍。

事实上，您的程序泄漏了。这是由于代码中太空船*的std:：vector造成的。STL向量容器只有在包含对象而不是指向对象的指针时，才会管理和释放其内部内存

在这里，当你将太空船添加到你的向量中，并且确实删除了alpha时，你的主程序中的sp1和sp2所指向的内存将不会被释放

在现代C++中，你应该避免使用任何原始指针，而应该尝试使用智能指针。在这里，我试图改变你的代码，我认为现在不会泄漏

太空船

#包括
#包括
#包括
#包括
#包括
阶级地位{
公众：
位置（标准：：字符串名称，双x，双y，双z）；
私人：
std：：字符串名；
双x，y，z；//三维地图上的坐标
};
班机{
公众：
飞行（位置*开始，位置*结束）；
~Flight（）；
作废printFlightPlan（）；
私人：
位置*开始；
位置*结束；
};
二级宇宙飞船{
公众：
宇宙飞船（标准：：字符串名称，飞行*飞行计划）；
~宇宙飞船（）；
作废printFlightPlan（）；
私人：
std：：字符串名；
飞行计划；
};
阶级宇宙{
公众：
宇宙（）；
~Universe（）；
太空船（标准：：共享）；
私人：
std:：vector*Spaceships；//一个宇宙飞船指针的向量
std:：vector:：迭代器开始、结束；
国际宇宙飞船；
};

“调用父类上的delete调用子类的析构函数”-

Spaceship

不是父类你的意思是

删除sp1？Shaktai：已修复。0x499602D2:误用了“parent”来表示它包含其他类。每个
new
/
new[]
都需要一个匹配的
delete
/
delete
，否则就会出现内存泄漏。类中的数据成员是指针，而不是对象，因此它们没有可调用的析构函数。如果对象是使用
new
创建的，则其生存期不会绑定到范围或对象。您需要
delete
来结束它的生命。“正确的方法是什么？”-使用智能指针和/或基于值的成员和容器。除了最稀罕的情况（这不是其中之一），在现代C++中，手动内存管理是可以避免的。这是您的项目中的三个类。想象一下，当你在你的等级体系中有几十个或几百个职业的时候，你会有一个节日。如果可以（而且可以）避免这种情况，并利用为您提供的工具。无关：仅供参考，包括
，而不是
谢谢：）太棒了！