C++ 如何避免虚拟关键字

如何在没有虚拟键的情况下访问派生类的成员函数

#include<iostream>
using namespace std;
class Employee{
public:
     void what(){
        cout<<"Employee"<<endl;
    }
};
class Secretary:public Employee{
    public:
    void what(){
        cout<<"Secretary"<<endl;
    }
};
class Manager:public Employee{
    public:
    void what(){
        cout<<"Manager"<<endl;
    }
};
class Director:public Manager{
    public:
    void what(){
        cout<<"Director"<<endl;
    }
};
void f(Employee*);
int main(){
    Employee a;
    Manager b;
    Director c;
    Secretary d;
    f(&a);
    f(&b);
    f(&c);
    f(&d);
    return 1;
}
void f(Employee *a){
    a->what();
}

它总是打印员工。我想打印每个对象的类名。

---

a.正确打印类名。但我必须在这个任务中使用指针和fEmployee*函数

必须重载void f函数来处理Manager数据类型

void f(Manager *a){
    a->what();
}

但它只适用于Manager数据类型，而不是从Manager派生的任何类

如果要创建一个函数来为employee类对它们进行规则化，并使用基类指针访问派生成员，则需要使用virtual关键字。这只是C++的要求。我确信还有其他方法，因为C++是非常灵活的，但是它们非常复杂，需要时间和额外的代码。 但是，只需要在基类中键入“virtual”，尽管这被认为是一种不好的做法。像这样：

class Employee{
public:
    virtual void what(){
        cout<<"Employee"<<endl;
    }
};

class Secretary:public Employee{
public:
    void what(){ /*Still inherits 'virtual' without typing it.*/
        cout<<"Secretary"<<endl;
    }
};

---

好的，这里有一个完全人为设计的方法，它没有使用@Stephen的注释所启发的虚拟方法-它只是将文本存储在基类中，这样当函数f对类进行切片时，数据仍然存在

#include<iostream>
using namespace std;
class Employee{
public:
    std::string name;
    Employee(std::string name = "Employee"):name(name){}
    void what(){
        cout<<name<<endl;
    }
};
class Secretary:public Employee{
    public:
    Secretary(std::string name = "Secretary"):Employee(name){}
};
class Manager:public Employee{
    public:
    Manager(std::string name = "Manager"):Employee(name){}
};
class Director:public Manager{
    public:
    Director(std::string name = "Director"):Manager(name){}
};
void f(Employee*);
int main(){
    Employee a;
    Manager b;
    Director c;
    Secretary d;
    f(&a);
    f(&b);
    f(&c);
    f(&d);
    return 1;
}
void f(Employee *a){
    a->what();
}

一种选择是：

void f(Employee*a) { a->what(); }
void f(Secretary*a) { a->what(); }
void f(Manager*a) { a->what(); }
void f(Director*a) { a->what(); }

您可以使用模板，而不是写出四份副本：

template<typename T>
void f(T *a) { a->what(); }

---

您可以在每个类型中放置一个标识符，以确定它是什么类型。。员工=1，经理=2，主管=3，然后打开该按钮。还有一种叫做标记分派的东西，你不能。虚函数是派生类存在的唯一原因。你的作业是否说你不应该使用虚拟函数？如果是这样，请退出。您可以对模板使用静态分派。这是允许的吗？@JerryJeremiah我想了想，但是如何通过多层次的继承来实现呢。e、 g.董事来自经理。@PaulRooney是的。我只是试着去做，结果发现这比我想象的要困难得多…f并不意味着这就是我的想法。我不知道他为什么不想要虚拟的