C++ Objekte teilen Attribut - verwenden Sie Zeiger oder Referenz

Question

Ich möchte eine Klasse schreiben, wo einige der Objekte ein gemeinsames Attribut teilen.

Am Ende habe ich etwas erstellt, das so aussieht: Ich habe eine Klasse A mit einem Vektor von Objekten B und einem Objekt C erstellt, wobei jedes Objekt b einen Verweis auf c speichert.

Class A{ 
    vector<B> v_b; 
    C c; 
} 

Class B{ 
    C& c; 
} 

Die Objekte im Vektor „V_B“ sollten in der Lage sein, „c“ (in c gespeichert hinzufügen, um einen Wert zu einem Vektor) zu ändern, wenn ein Objekt einen Wert hinzufügt, ist es auch für alle anderen objets hinzugefügt werden soll im Vektor "v_b". Das war der Hauptgrund, warum ich dieses Objekt "teilen" wollte.

Am Ende funktioniert es nicht so, wie ich es will und ich muss dieses Problem überdenken.

Meine Frage ist jetzt, ist es besser, C als Referenz zu speichern oder Zeiger zu verwenden?

Am Ende brauche ich wirklich nur den Vektor "v_b", ich bin nicht an der Klasse A interessiert, ich habe A nur verwendet, um ein paar A-Objekte mit "v_b" Vektoren zu erstellen und dann habe ich a Getter alle "v_b" zu bekommen und speichern sie in einem gemeinsamen Vektor.

Beispiel:

vector<b> v; 
{ 
    A a1; 
    a1.add_b_to_vector(B b1); // b1 and b2 should share a common c 
    a1.add_b_to_vector(B b2); 
    A a2; 
    a2.add_b_to_vector(B b3); // b3 and b4 should share a common c 
    a2.add_b_to_vector(B b4); 
    v.push_back(a1.get_vector_of_bs()); //lets assume push_back would work 
    v.push_back(a2.get_vector_of_bs()); 
} 
// do something with v 

Danke für Ihre Hilfe

Answer 1

Sie werden wahrscheinlich einen Zeiger wollen, keine Referenz. Ein Verweis macht es unmöglich, den Zuweisungsoperator auf natürliche Art und Weise zu nutzen:

class B 
{ 
public: 
    B(const B&) = default; 
    B& operator=(const B&) = default; 

private: 
    C& c; 
}; 

void assign(B& b1, const B& b2) 
{ 
    b1 = b2; // this will not work! operator= is deleted 
} 

Sie keine Referenz rebind kann, also wenn &(b1.c) != &(b2.c) in dem obigen Beispiel ist es unmöglich, b2 zu b1 zuzuweisen.

Die richtige Lösung wäre, so etwas zu tun:

class B 
{ 
public: 
    B(C& _c) : c{ &_c } {} 

    B(const B&) = default; 
    B& operator=(const B&) = default; 

private: 
    C* c; 
}; 

Dies stellt sicher, dass Sie nie mit einem Null-Zeiger-Wert für c noch am Ende, während in dem Sie den Zuweisungsoperator auf natürliche Weise zu verwenden, .

Nebenbei ist dies ein Beispiel für die flyweight pattern. Vielleicht finden Sie die Bibliothek nützlich, um das Rad nicht neu zu erfinden.