c++ - 不在基类和派生类中调用虚拟析构函数

Question

以下代码涉及4个类。

1. 基类是 Person 类，有两个派生类 Student 和 Lecturer。每个人都支持两个函数:toString() 和 type()。 Type() 返回该类的名称，而 toString() 打印实例(学生或讲师)的信息。

2. Person 是一个抽象类，但 Student 和 Lecturer 都是具体类。

我已经实现了以上两个功能。

1. 许多讲师将共享指向同一个 SalaryTable 的指针，可能有其他 SalaryTable(支持相同的功能)并且讲师不拥有 SalaryTable。此外，它们每个都有一些额外的功能。

谁能单独给我解释一下第三点？据我所知，我使用了 Lecturer 构造函数中给出的 SalaryTable 指针，并将其分配给我在 Lecturer.h 中添加的 SalaryTable 指针 (salaryTable_)。然后我使用 salaryTable_->annualSalary(grade_) 返回薪水。在 ~Lectuere() 的析构函数中，我删除了 salaryTable_。

这样做正确吗？当我这样做时，只有 ~Salary() 析构函数被调用，基类析构函数 (~Person()) 和派生类析构函数 (~Student() & ~Lecturer()) 都没有被调用。谁能解释我哪里错了？

主要.cpp

int main(int argc, char* argv[]) {

    if (argc == 1) {
        SalaryTable st;
        Person* arr[2];
        arr[0] = new Student("Apolo",5);
        arr[1] = new Lecturer("Zeus","CO7100",33,&st);

        for (unsigned int i=0 ; i<2 ; ++i) {
            if (arr[i]->type() == "Student") {
                Student* s=dynamic_cast<Student*>(arr[i]);
                s->addMCF("blah blah");
                s->addMCF("");
                s->addMCF("Something else");
            }
        }
        for (unsigned int i=0 ; i<2 ; ++i) {
            cout << *arr[i] << endl;
        }
    }
}

薪水表.h

#ifndef SALARYTABLE_H_
#define SALARYTABLE_H_

class SalaryTable {
public:
    SalaryTable();
    ~SalaryTable();

    unsigned int annualSalary(unsigned int grade) const;
};

#endif /* SALARYTABLE_H_ */

人.h

#ifndef PERSON_H_
#define PERSON_H_

#include <string>
#include <iosfwd>
#include <vector>

#include "SalaryTable.h"

using std::vector;
using std::string;

class Person {
public:
    Person() = delete;
    Person(const Person&) = delete;
    Person(Person&&) = delete;

    Person(const char* name);
    Person(const std::string& name);
    virtual ~Person();

    // Return the name of the Person
    // Should be supported by all Persons.
    std::string name() const;

    virtual std::string toString() const=0;

    virtual std::string type() const=0;

    friend std::ostream& operator<<(std::ostream&, const Person&);
private:
    std::string name_;
};

学生.h

class Student: public Person {
public:
    Student() = delete;
    Student(const Student&) = delete;
    Student(Student&&) = delete;

    Student(const char* name, unsigned int studentId);
    Student(const std::string& name, unsigned int studentId);
    virtual ~Student();

    void addMCF(const std::string&);
    std::string MCF(unsigned int);

    unsigned int id() const;

    std::string toString() const;
    std::string type() const;

private:
    unsigned int studentId_;
    vector<string> vec_;
};

讲师.h

class Lecturer: public Person {
public:
    Lecturer() = delete;
    Lecturer(const Lecturer&) = delete;
    Lecturer(Lecturer&&) = delete;

    Lecturer(const char* name, const char* teaches, unsigned int grade,
            SalaryTable*);
    Lecturer(const std::string& name, const std::string& teaches,
            unsigned int grade, SalaryTable*);
    virtual ~Lecturer();

    void increaseGrade();
    unsigned int salary() const;

    void changeModule(const std::string& newModule);
    std::string teaches() const;

    std::string toString() const;
    std::string type() const;

private:
    string teaches_;
    string module_;
    unsigned int grade_;
    SalaryTable& salaryTable_;

};

#endif /* PERSON_H_ */

注意:请注意，我无法更改 .h 文件。

我收到了很多关于销毁指针的意见。但我的最终问题是:为什么除了 SalaryTable 类之外的所有其他类都没有被销毁。我通过在所有类的析构函数中打印一个 stmt 来验证它。任何人都可以对此有所了解。

“也添加了 main.cpp 文件，我也不能修改它。”

Answer 1

您必须决定谁拥有 SalaryTable，每个 Lecturer 在构造时都会收到一个指针。有两个类似的选项。

(1) 该表明确归另一个类/代码所有(未在您的问题中显示)，那么 Lecturer 应该保留一个观察指针(或引用)到从未用于删除 和代码布局必须保证 SalaryTable 在任何 Lecturer 观察它之前不会被破坏。

(2) 您可以使用 std::shared_ptr 确保后者，但这是有代价的，也意味着 SalaryTable 没有所有者，但是所有保留 shared_ptr 的代码部分共同保留所有权。

对我来说 (1) 似乎更符合逻辑:SalaryTable 是一个独立于任何 Lecturer 存在的基本对象，应该在任何 Lecturer< 之前创建 并在任何 Lecturer 之后销毁。如果您没有使用它的经验，我还建议避免使用 shared_ptr。