Question

我正在用C ++为我的学校开展一个项目

我有2个班：员工和老师。老师来自员工，并且已经超越了他的职能。

我们覆盖运营商<<以打印员工或教师的一些信息。每个班级都有一个const int attribute LevelAcces_。员工， 5 ，教师 20 。

当我在main.cpp中创建一个教师时，我调用了操作符的覆盖＆lt;＆lt;老师打印他的信息。所以这个函数叫做：

ostream& operator<<(ostream& os, const Teacher& pTeacher){
    os << (pTeacher);
    return os;
}

但是，函数使用行"os << (pTeacher);"调用自身，执行导致堆栈溢出的循环。

我希望第"os << (pTeacher)"行调用运算符＆lt;＆lt;我的班级员工而不是班级老师。

覆盖运营商＆lt;＆lt;在员工：

ostream& operator<<(ostream& os, const Employe& pEmploye){
    os << "Name: " << pEmploye.name_ << endl;
    os << "Class: " << pEmploye.getClass() << endl;
    os << "LevelAcces: " << pEmploye.getLevelAccess() << endl;
    return os;
}

我试图将我的老师变成雇员，但是当它打印出消息时，LevelAcces为5（我想要20，因为我的员工是教师）。

我还尝试使用Employe :: operator＆lt;＆lt;但是运营商＆lt;＆lt;不是员工的成员，所以它不起作用......

所以，这是我的问题：

如何使用我的运算符＆lt;＆lt;在我的运营商中的雇员＆lt;＆lt;教师并打印正确的信息（LevelAccess = 20而不是5）？

我也在考虑“虚拟”，但我们的教授告诉我们不需要使用这个词。

提前致谢：）

这是一个更完整的代码：

main.cpp中：

Teacher Garry("Garry");
cout << Garry << endl;

Employe.cpp：

#include "Employe.h"

using namespace std;

Employe::Employe(){
    name_ = "";
}

Employe::Employe(string pName){
    name_ = pName;
}

string Employe::getName() const{
    return name_;
}

unsigned int Employe::getLevelAccess() const{
    return levelAccess_;
}

string Employe::getClass() const{
    return typeid(*this).name();
}

ostream& operator<<(ostream& os, const Employe& pEmploye){
    os << "Name: " << pEmploye.name_ << endl;
    os << "Class: " << pEmploye.getClass() << endl;
    os << "LevelAcces: " << pEmploye.getLevelAccess() << endl;
    return os;
}

在Employe.h中使用它：

private:
    static const unsigned int LevelAccess_ = 5;

Teacher.cpp：

#include "teacher.h"
using namespace std;

Teacher::Teacher(string pName){
    nom_ = pName;
}

unsigned int Teacher::getLevelAccess() const{
    return(Employe::getLevelAccess() + accessTeacher_); 
}
string Teacher::getClass() const{
    return typeid(*this).name();
}

ostream& operator<<(ostream& os, const Teacher& pTeacher){
        os << (pTeacher);
        return os;
}

这是Teacher.h：

static const unsigned int accesTeacher_ = 15;

Answer 1

我要做的是以下内容：只定义一个

ostream& operator<<(ostream& os, const Employe& pEmploye)
{
    return pEmploye.display(os);
}

作为层次结构的基础，在其中调用受保护的成员函数virtual display()，该函数被每个派生类覆盖并且被委派给显示器。这有时称为NVI（非虚拟接口）习语。它的工作原理如下：

class Employee
{
    // ...
    friend ostream& operator<<(ostream& os, const Employee& pEmployee)
    {
        return pEmployee.display(os);
    }
protected:
    virtual ostream& display(ostream& os) const
    {
        // implement it here
        return os;
    }
};

class Teacher: public Employee
{
    // ....
protected:
    ostream& display(ostream& os) const override
    {
        // implement it here
        return os;
    }
};

Answer 2

你可以使用演员：

os << static_cast<const Employe &>(pTeacher);

&很重要。

要从Teacher::getLevelAccess()引用调用成员函数调用Employe，您必须使该函数成为虚拟函数。（在teacher.h中执行此操作）。 getClass()也应为virtual。

NB。您一直在说“在Employe中覆盖operator<<：”，但您在Employe中没有超载operator<<。你有一个以Employe为参数的自由函数。

覆盖运算符＆lt;＆lt;在c ++中

2 个答案: