Die gleiche Methode in abgeleiteten Klassen, aber mit anderen Parametern

Question

Ich weiß nicht, wie ich mein Problem beschreiben soll. Ich würde gerne herausfinden, ob es möglich ist, eine Funktion in der Basisklasse zu schreiben, die für abgeleitete Klassen die gleiche wäre, aber verschiedene Parameter übergibt. Vielleicht wäre es einfacher, in meinem Code zu sehen, als es die Beschreibung:

class Employee 
{ 
public: 
    std::string name, profession; 
    std::string current_task = "NONE"; 
    int id, age; 

    // checks if the input by user a new task belongs to duties list 
    // for the class; if it does then it changes the current task 
    std::string AssignNewTask(std::vector<std::string> v, std::string input_string) 
    { 
     for (unsigned int i = 0; i < v.size(); i++) 
     { 
      if (input_string == v[i]) 
      { 
       return input_string; 
      } 
     } 

     return "NONE"; 
    } 
}; 

class HR : public Employee 
{ 
private: 
    static std::vector<std::string> tasks; //list of duties for HR employees 

public: 
    HR::HR() 
    { 
     Employee::profession = "HR Specialist"; 
    } 
    //the same function as above but passing tasks (std::vector with duties) 
    std::string AssignNewTask(tasks, std::string input_string) 
}; 

std::vector<std::string> HR::tasks = { "something" }; 

int main() 
{ 
    HR obj; 
    // 'something1' does not belong to duties list so still "NONE" 
    obj.AssignNewTask("something1"); 
    // 'something' belongs so current_task has been changed 
    obj.AssignNewTask("something"); 
} 

Ich weiß, dass der Code funktioniert nicht. Ich wollte nur zeigen, was ich genau meine.

Answer 1

Also wenn ich das Ziel richtig verstehe;

• Wir wollen eine Basisklasse haben, die eine AssignNewTask Funktion
• bietet, die die Aufgabe nur vergeben werden, wenn es in der Aufgabenliste der abgeleiteten Klasse enthalten ist.

Die folgende angepasste Version des Programms macht das. AssignNewTask ist in der Basis, aber während der Konstruktion erhält es einen Verweis auf die Aufgabenliste der abgeleiteten Klasse.

#include <vector> 
#include <string> 

class Employee { 
public: 
    Employee(std::vector<std::string>& tasks) : tasks{tasks} {}; // we need a constructor here to pass the reference to the tasks 
    std::string name,profession; 
    std::string current_task = "NONE"; 
    int id,age; 

    std::vector<std::string>& tasks; // tasks now refers to the derived list of tasks 

    // checks if the input by user a new task belongs to duties list for the class; if it does then it changes the current task 
    virtual void AssignNewTask(std::string input_string) 
    { 
     for (unsigned int i = 0; i < tasks.size(); i++) { 
      if (input_string == tasks[i]) { 
       current_task = input_string; 
      } 
     } 
    } 
}; 

class HR : public Employee { 
public: 
    HR::HR() 
     : Employee(tasks) // We now pass the list of tasks by reference 
    { 
     Employee::profession = "HR Specialist"; 
    } 

    //AssignNewTask not required here as it has already been inherited 

private: 
    static std::vector<std::string> tasks; //list of duties for HR employees 

}; 


std::vector<std::string> HR::tasks ={"something"}; 

int main() 
{ 
    HR obj; 

    obj.AssignNewTask("something1"); // 'something1' does not belong to duties list so still "NONE" 
    obj.AssignNewTask("something"); // 'something' belongs so current_task has been changed 
} 

Sie können auch einen range based for loop eher als das bevorzugen wir derzeit haben:

for (const auto& task : tasks) { 
    if (input_string == task) { 
     current_task = input_string; 
    } 
} 

Answer 2

ich herausfinden möchte, ob es möglich ist, eine Funktion in der Basis Klasse zu schreiben, die das gleiche für abgeleitete Klassen es sein würde, aber vorbei verschiedene Parameter

Es ist möglich, aber Versteckt die Basisfunktion im Kontext, wenn Sie versuchen, den Polymorphismus zu erreichen, indem Sie den Basiszeiger verwenden, der dem abgeleiteten Klassenobjekt zugeordnet ist.

Answer 3

Es scheint viele Probleme mit Ihrem Code zu geben. Wenn Sie möchten, dass eine Basisklasse Ihre übergeordnete Klassenfunktion überschreibt, muss das übergeordnete Element die Funktion als virtual deklarieren. Als nächstes scheinen die Methoden die gleichen Parameter zu haben. Sie verwirren nur die HR-Instanz eines Vektors mit dem tatsächlichen Typ des Vektors. Wie wäre es, wenn Sie den Vektor der Zeichenfolgen für beide Klassen schreiben:

// new type now named StringVector 
typedef std::vector<std::string> StringVector; 

class Employee 
{ 
public: 
    std::string name, profession; 
    std::string current_task = "NONE"; 
    int id, age; 

    // checks if the input by user a new task belongs to duties list for the class; if it does then it changes the current task 
    virtual std::string AssignNewTask(StringVector v, std::string input_string) 
    { 
     for (unsigned int i = 0; i < v.size(); i++) 
     { 
      if (input_string == v[i]) 
      { 
       return input_string; 
      } 
     } 

     return "NONE"; 
    } 
}; 

class HR : public Employee 
{ 
private: 
    static StringVector tasks; //list of duties for HR employees 

public: 
    HR::HR() 
    { 
     Employee::profession = "HR Specialist"; 
    } 

    std::string AssignNewTask(StringVector tasks, std::string input_string) 
    { 
     // do something 
    } 

}; 

std::vector<std::string> HR::tasks = { "something" }; 

int main() 
{ 
    HR obj; 

    obj.AssignNewTask("something1"); // 'something1' does not belong to duties list so still "NONE" 
    obj.AssignNewTask("something"); // 'something' belongs so current_task has been changed 
} 

Ich hoffe, das beantwortet Ihre Frage für Sie.