Vererbung und kleine Anzahl von Parametern

Question

Onkel Bob in seinem Clean Code legen nahe, dass nicht mehr als 3 Argumente sollen eine Funktion erhalten:

Funktionen, die drei Argumente sind wesentlich schwerer verstehen als Dyaden. Die Probleme beim Bestellen, Pausieren und Ignorieren von werden mehr als verdoppelt. Ich schlage vor, Sie denken sehr sorgfältig vor Erstellen einer Triade.

Aber was ist mit CTOR-Argumenten in Klassenvererbungshierarchie? Was, wenn jede Klasse in der Hierarchie ein neues Feld hinzufügt und Sie diese in CTOR initialisieren sollten. Sehen Sie ein Beispiel unter:

class Person 
{ 
private: 
    std::string m_name; 
    int m_age; 

public: 
    Person(const std::string& name, const int age); 
    std::string getName() const { return m_name; } 
    int getAge() const { return m_age; } 
    ~Person(); 
}; 


class Student : public Person 
{ 
private: 
    std::string m_university; 
    int m_grade; 

public: 
    Student(const std::string& name, const int age, const std::string& university, const int grade); 
    std::string getUniversity() const { return m_university; } 
    int getGrade() const { return m_grade; } 
    ~Student(); 
}; 

Sehen Sie, wie Student 4 Argumente bekommt, während Person bekommt nur 2 und Student fügt zwei weitere. Wie sollen wir damit umgehen?

Answer 1

Es gibt mehrere Möglichkeiten.

Kombinieren Sie mehrere Parameter in eine struct

struct PersonInfo { 
    std::string name; 
    int age; 
}; 

struct StudentInfo { 
    PersonInfo person_info; 
    std::string university; 
    int grade; 
}; 

Person::Person(const PersonInfo &info) :m_name(info.name), m_age(info.age) {} 
Student::Student(const StudentInfo &info) : Person(info.person_info), m_university(info.university), m_grade(info.grade) {} 

Standarddatenelemente initialisieren und stellte sie mit Setter Dienstprogramme

Person::Person() : m_age(0) {} 
void Person::set_age(int age) { m_age = age; } 

Student() : m_grade(0) {} // Person is default constructed. 
void Student::set_grade(int grade) { m_grade = grade; } 

Answer 2

ich würde sagen, dass dies nur ein Vorschlag. es liegt ganz bei Ihnen - wie viele Argumente sollten Ihre Funktionen bekommen.

aber wenn Sie es vorziehen, um die Regel zu folgen, eine Art von Parametern Halter machen, wie:

class Student 
{ 
    public: 
    struct StudentParameters 
    { 
     ... 
    }; 
    Student(name, age, const StudentParameters &sp); 
... 
}; 

Answer 3

Du verwechselst zwei verschiedene Bedeutungen des Wortes function.

Die erste Bedeutung ist mehr auf die ursprüngliche mathematische Bedeutung des Wortes bezogen. In diesem Fall ist function eine benannte Beziehung zwischen einem oder mehr Eingänge und genau einem Ausgang. Die "Clean Code" -Regeln beziehen sich auf diese Bedeutung und weisen darauf hin, dass mehr auf 3 Eingänge begrenzt werden sollte.

Die alternative Bedeutung in C++ bezieht sich auf einen Codeblock, der Eingaben enthalten kann oder kann, die eine Ausgabe haben können oder dürfen, die einen Namen haben kann oder darf.

Und ja, auch im letzteren Sinne sind Konstruktoren ungewöhnliche Funktionen. Sie haben nie einen Rückgabetyp, nicht einmal void, und sie haben keine Namen. Sie können also argumentieren, dass sie auch speziell sind, wenn es um ihre Anzahl von Eingabeargumenten geht.