So vermeiden Sie doppelte Kopien der Basisklassenelemente in der abgeleiteten Klasse in C++

Question

In meinem Projekt gibt es eine Basisklasse und es gibt 3 verschiedene abgeleitete Klassen. Ich habe einige Makrovariablen, die in der Basisklasse als const int geschrieben sind. Alle abgeleiteten Mitglieder werden auf diese Mitglieder zugreifen und denselben Wert sehen. Da es ein const ist, und es wird sich nicht ändern, wird die Beibehaltung von 3 verschiedenen Werten Platzverschwendung sein. Daher möchte ich einen Weg, um nur eine Kopie der Konstanten der Basisklasse beizubehalten, so dass alle abgeleiteten Klassen die gleichen verwenden.

Beispiel

//Base.hpp 
Class Base { 

     const int ZER0; 
     const int ONE; 
}; 

//Derived1.hpp 
class Derived1:public Base { 
     int some_method1(); 
}; 

    //Derived1.cpp 

    int Derived1::some_method1() { 

    int value = ZERO; 
    } 

//Derived2.hpp 

class Derived2:public Base { 
    int some_method2(); 
}; 

//Derived2.cpp 

int Derived2::some_method2() { 
    int value = ONE; 
} 

//main.cpp 

Derived1 d1; 
d1->some_method1(); 

Derived d2; 
d2->some_method2(); 

// Hier in beiden Verfahren die Werte konstant sind, aber immer noch die Null und Eins gehen anderen Raum haben. Gibt es einen Weg, wo ich nur eine Kopie aufbewahre? Ich könnte an statische Variable denken. Ist es in Ordnung, statische innerhalb der Klasse zu verwenden und wo initialisiere ich die statische Variable. Bitte um Rat.

PS: Diese Fragen könnten ein Duplikat sein, aber ich kann etwas mit ähnlichen Wörtern nicht finden, wenn Sie das Gefühl haben, wenden Sie sich bitte an den entsprechenden Artikel/Frage;

Answer 1

Wenn ich Sie richtig verstehe, würde ein enum tun, was Sie suchen?

class Base 
{ 
    enum 
    { 
     ZERO, 
     ONE 
    }; 
}; 

Answer 2

Ich glaube, Sie möglicherweise virtuelle Basis inheritence verwenden, um eine Kopie der Basis zu halten ..

//Base.hpp 
class Base { 
public: 
    Base() {} 
    virtual ~Base() {} 
protected: 
    static const int ZER0; 
    static const int ONE; 
}; 

//Base.cpp 
const int Base::ZER0 = 0; 
const int Base::ONE = 1; 

//Derived1.hpp 
class Derived1 : public virtual Base { //using virtual keyword here maintains one copy of base class, thus one copy of ONE and ZERO for all objects since they are static members of Base. You must read about diamond problem of virtual inheritence to understand this properly. 

public: 
    Derived1() :Base() {} 
    int method1(); 
}; 

//Derived1.cpp 

int Derived1::method1() { 
    int value = ZER0; 
    return value; 
} 

//Derived2.hpp 

class Derived2 : public virtual Base { 
public: 
    Derived2() :Base() {} 
    int method2(); 
}; 

//Derived2.cpp 

int Derived2::method2() { 
    int value = ONE; 
    return value; 
} 

//main.cpp 


int main() { 
    Derived1 d1; 
    d1.method1(); // . instead of -> , -> is used for member access through pointers 

    Derived2 d2; 
    d2.method2(); 

    return 0; 
}