Wie vermeidet man das virtuelle Schlüsselwort

Question

Wie kann ich abgeleitete Klasse Mitgliedsfunktion ohne virtuellen Schlüssel erreichen.

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

Es druckt immer "Mitarbeiter". Ich möchte den Klassennamen jedes Objekts drucken. und a.what() druckt den Klassennamen korrekt. Aber ich muss Zeiger und f (Mitarbeiter *) Funktion für diese Aufgabe verwenden.

Answer 1

Sie müssten die Funktion void f() überladen, um den Manager-Datentyp zu verarbeiten.

Aber es wäre nur für Manager-Datentypen und keine der vom Manager abgeleiteten Klassen genau.

Wenn Sie eine Funktion erstellen möchten, um alle für die Mitarbeiterklasse zu steuern und Basisklassenzeiger für den Zugriff auf abgeleitete Elemente zu verwenden, müssen Sie das Schlüsselwort virtual verwenden. Es ist nur eine Voraussetzung von C++. (Ich bin mir sicher, dass es andere Möglichkeiten gibt, denn C++ ist extrem flexibel, aber sie sind sehr kompliziert und benötigen Zeit und zusätzlichen Code.)

Sie müssten jedoch nur 'virtual' in die Basisklasse eingeben, obwohl das als schlechte Praxis gilt. Wie so:

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 2

Ok, hier eine völlig erfundene Methode, die nicht virtual durch den Kommentar von @Stephen inspirierte Anspruch nimmt - es speichert nur den Text in der Basisklasse, so dass, wenn die Funktion f Scheiben die Klasse Die Daten sind noch da.

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

Answer 3

Eine Option ist:

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