为什么我的重载运算符不适用于派生类

Question

我试图学习 C++ PL 中的运算符重载。我做了一个如下所示的练习。我想要做的是为每个派生类重载

班级员工：

class Employee {
public:
    string name;
    int id;
    int exp_level;
    double salary;

    Employee() {
        this->name = "";
        this->id = 0;
        this->exp_level = 0;
        this->salary = 0.0;
    }

    ~Employee() {
        //WTF
    }

    virtual void calculateSalary() {
        //CODE
    }
    
    virtual void registerX() {
        //CODE
    }

    friend ostream& operator<<(ostream& os, const Employee& e) {
        os << e.name << " " << e.exp_level << " " << e.id << " " << e.salary << endl;
        return os;
    }
};

技术类：

class Technical : public Employee {
public:
    string profession;

    Technical() {
        this->profession = "";
    }

    ~Technical() {

    }

    virtual void calculateSalary() {
        //CODE
    }

    virtual void registerX() {
        //CODE
    }

    friend ostream& operator<<(ostream& os, const Technical& e) {
        os << e.name << " " << e.exp_level << " " << e.id << " " << e.salary << "Technical" << endl;
        return os;
    }
};

类工程师：

class Engineer : public Employee {
public:
    Engineer() {

    }

    ~Engineer() {

    }

    virtual void calculateSalary() {
        //CODE
    }

    virtual void registerX() {
        //CODE
    }

    friend ostream& operator<<(ostream& os, const Engineer& e) {
        os << e.name << " " << e.exp_level << " " << e.id << " " << e.salary << "Engineer" << endl;
        return os;
    }
};

主要方法：

int main()
{
    Employee* e = new Employee();
    Employee* t = new Technical();
    Employee* ee = new Engineer();

    cout << *e << endl;
    cout << *t << endl;
    cout << *ee << endl;    
}    

输出：

 0 0 0

 0 0 0

 0 0 0

Answer 1

C++ 根据函数参数的静态类型选择最佳重载，因为在这种情况下类型是Employee，Employee 的operator<< 被调用.

如果你希望它在你有一个与其动态类型不匹配的静态类型指针/引用时调用正确的版本，你将不得不使用虚函数或使用dynamic_casts/typeid 来检查具体的运行时类型（虚拟函数是最干净的方法恕我直言）

示例：godbolt

class Employee {
public:
    virtual ~Employee() = default;

    friend std::ostream& operator<<(std::ostream& os, const Employee& e) {
        return e.put(os);
    }

protected:
    virtual std::ostream& put(std::ostream& os) const {
        os << "Employee!";
        return os;
    }
};

class Technical : public Employee {
protected:
    std::ostream& put(std::ostream& os) const override {
        os << "Technical Employee!";
        return os;
    }
};

class Engineer : public Employee {
protected:
    std::ostream& put(std::ostream& os) const override {
        os << "Engineer Employee!";
        return os;
    }
};

int main() {
    Employee* e = new Employee();
    Employee* t = new Technical();
    Employee* ee = new Engineer();

    std::cout << *e << std::endl;
    std::cout << *t << std::endl;
    std::cout << *ee << std::endl;

    delete ee;
    delete t;
    delete e; 
}

会导致：

Employee!
Technical Employee!
Engineer Employee!

---

还要记住，一旦你在一个类中至少有 1 个虚函数，那么析构函数几乎肯定也是虚函数。

例如：

Employee* e = new Technical();
delete e;

如果析构函数不是虚拟的，则只会调用~Employee()，但不会 ~Technical()。

因此，每当您想通过指向其基类之一的指针删除对象时，析构函数必须是虚拟的，否则它是未定义的行为。

Answer 2

由于这些声明

Employee* e = new Employee();
Employee* t = new Technical();
Employee* ee = new Engineer();

表达式*e、*t、*ee的静态类型为Employee &。所以运营商

friend ostream& operator<<(ostream& os, const Employee& e)

为所有三个对象调用。

使友元运算符

virtual std::ostream & out( std::ostream & ) const;

并定义（唯一的）友元运算符，如

friend ostream& operator<<(ostream& os, const Employee& e)
{
    return e.out( os );
}

每个派生类都需要重新定义虚函数out。