Gibt es eine Möglichkeit, ein Array/Vektor zu erstellen, das Verweise auf verschiedene Arten von Variablen enthält?

Question

Ich habe meinen Kopf schon seit geraumer Zeit wurde hämmern jetzt ein Array/Vektor zu erstellen versuchen, die Verweise auf verschiedene Arten von Variablen finden Sie im Beispiel enthalten:

class Validate 
{ 
private: 
    some_array/vector[]; //0 would refer to x, 1 to y, and so on.. 
    uint8_t x; 
    uint16_t y; 
    int32_t z; 
public: 
    Validate(); 
    void doSomething(uint8_t &member); 
    void doSomething(uint16_t &member); 
    void doSomething(int32_t &member); 
} 

Der springende Punkt ist, so dass ich kann mit diesem Array/Vektor leicht in einem „for-Schleife“, so etwas wie:

void Validate::doSomething(uint_8 &member) 
{ 
    //Do whatever with the variable refered to. 
} 
Validate::Validate() 
{ 
    for(int i = 0 ; i < 2 ; i++) 
     doSomething(some_array/vector[i]); 
} 

Vielleicht eine jemand hat Antwort oder vielleicht eine bessere Lösung für mich.

Answer 1

Sie haben zwei Probleme. Erstens kann ein Container keine Elemente verschiedener Typen enthalten. Zweitens können Sie keine Referenzen in einem Container speichern.

Eine Möglichkeit, das erste Problem zu lösen, ist std::variant aus C++ 17 (oder boost::variant). Um das zweite Problem zu lösen Sie std::reference_wrapper verwenden:

class Validate { 
    using Uint8Ref = std::reference_wrapper<uint8_t>; 
    using Uint16Ref = std::reference_wrapper<uint16_t>; 
    using Uint32Ref = std::reference_wrapper<int32_t>; 
    using MemberType = std::variant<Uint8Ref, Uint16Ref, Uint32Ref>; 

    std::vector<MemberType> members; 
    uint8_t     x; 
    uint16_t    y; 
    int32_t     z; 

public: 
    Validate(); 
    void doSomething(uint8_t &member); 
    void doSomething(uint16_t &member); 
    void doSomething(int32_t &member); 
}; 

Validate::Validate() : members({std::ref(x), std::ref(y), std::ref(z)}) {  
    for (auto member : members) { 
     std::visit([this](auto member){this->doSomething(member);}, member); 
    } 
} 

Live demo.

Alternativ können Sie eine polymorphe Basisklasse für ein Mitglied erstellen, die Sie in einem Behälter gespeichert werden können:

class MemberType { 
public: 
virtual ~MemberType(){} 
virtual void accept(Validate& validate) = 0; 
}; 

class Validate {  
    std::array<std::unique_ptr<MemberType>, 3> members; 
    // as before... 
}; 

template<typename T> 
class MemberTypeImpl : public MemberType { 
    T& member; 
public: 
    MemberTypeImpl(T& member) : member(member){} 
    void accept(Validate& validate) override { 
    validate.doSomething(member); 
    } 
}; 

template<typename T> 
std::unique_ptr<MemberType> make_member_type(T& member) { 
    return std::make_unique<MemberTypeImpl<T>>(member); 
} 

Validate::Validate() 
    : members({make_member_type(x), make_member_type(y), make_member_type(z)}) { 
    for (auto& member : members) { 
     member->accept(*this); 
    } 
}