Question

如何在没有虚拟键的情况下到达派生类的成员函数。

#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.what（）正确打印它的类名。但是我必须在这个赋值上使用指针和f（Employee *）函数。

Answer 1

好的，这是一个完全设计的方法，它不使用{@ 1}}受@Stephen注释的启发 - 它只是将文本存储在基类中，这样当函数f对类进行切片时数据就是还在那里。

coll.update(document)

Answer 2

您必须重载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;
    }
};

Answer 3

一个选项是：

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(); }

如何避免虚拟关键字

3 个答案: