für die Klasse mit einer großen Anzahl von Elementen

Question

Ich habe eine Klasse, die wie

class A{ 
    double a, b, c, d, e; 
    float af, bf, cf, df, ef; 
    std::vector<double> av, bv, cv, dv, ev; 
    std::vector<std::vector<double>> avv, bvv, cvv, dvv, evv; 

    A(){} 
    A(/*init values*/){/*Initialize all the values above using the input values*/} 
    ~A(){} 
} 

Nun würde Ich mag einen Zuweisungsoperator implementieren, so dass ich tun kann (in einer zweiten Klasse):

class B{ 
    private: 
     A ac, bc, dc; 
    public: 
     B(/*init values*/) 
     { 
      ac = A(/*init values*/); 
      bc = A(/*init values*/); 
      dc = A(/*init values*/); 
     } 
     ~B(){} 
} 

ich weiß, dass ich What is the copy-and-swap idiom? und What are the basic rules and idioms for operator overloading? folgen können und implementieren

A& A::operator=(A rhs) 
{ 
    swap(rhs); 
    return *this; 
} 

und die jeweilige swap -function:

friend void swap(A& first, A& second) 
{ 
    using std::swap; 

    swap(/*for each element*/); 
} 

tun so für alle Elemente ist anfällig für ein Element zu vergessen, was zu Fehlern in dem Code. Dasselbe gilt für Erweiterungen in der Zukunft, d. H. Hinzufügen von Variablen im Klassenheader, aber nicht in der Swap-Funktion. Gibt es dafür einen einfacheren Weg?

Answer 1

Sie könnten alle Datenmembers in einem Aggregat setzen und einfach keinen Konstruktor, Zuweisungsoperator und Destruktor deklarieren. Sie werden die Vorteile der Standard verschieben/Copykonstruktor/Zuordnung und Aggregat Initialisierung erhalten (die Ihnen helfen können, wenn die Initialisierung gerade nach vorne ist):

struct A{ 
    double a, b, c, d, e; 
    float af, bf, cf, df, ef; 
    std::vector<double> av, bv, cv, dv, ev; 
    std::vector<std::vector<double>> avv, bvv, cvv, dvv, evv; 
    }; 
void swap(A& a,A& b){ 
    a=std::exchange(b,a); 
    } 

Wenn Sie einige Invarianten zu halten haben, kann es hilfreich sein zu erklären, die Daten in einer inneren Struktur:

class A{ 
    struct data_t{ 
    double a, b, c, d, e; 
    float af, bf, cf, df, ef; 
    std::vector<double> av, bv, cv, dv, ev; 
    std::vector<std::vector<double>> avv, bvv, cvv, dvv, evv; 
    }; 
    data_t data; 
    //[...] 
    void swap(A& other){ 
    data = std::exchange(other.data,data); 
    } 
    };