eine Anordnung innerhalb einer Vereinigung in einer Klasse C++ Initialisieren

Question

ich etwas dieser Art haben:

SomeClass { 
public: 
    union { 
     int m_256[256]; 
     int m_16[16][16]; 
     int m_4[4][4][4][4]; 
    } 

    SomeClass() { 
     // Initialize Array to some default value 
     for (unsigned u = 0; u < 256; u++) { 
      m_256[u] = 0; 
     } 
    }   
}; 

Mit dem Verständnis der Gewerkschaften der for-Schleife im Konstruktor m_256 allen 0s initialisieren und die anderen 2-Arrays nur eine andere Version oder ein Alias ​​davon, daher sollten diese Arrays ebenfalls initialisiert werden, da die Speichergröße genau gleich ist und der Speicher geteilt wird.

Ich würde es vorziehen, nicht durch eine for-Schleife zu gehen, um alle Werte des Arrays auf einen Standardwert zu initialisieren. Da es in dieser Union 3 Arrays gibt, können Sie nur 1 nicht statisches Element mit einer Initialisierungsliste innerhalb einer Union haben. Das ist also gültig.

union { 
    int m_256[256]{}; 
    int m_16[16][16]; 
    int m_4[4][4][4][4]; 
} 

Anstelle der in den Konstruktor für die Schleife zu verwenden oder die gleiche Zahl manuell 256mal eingeben, gibt es eine kurze Hand Methode, die alle Werte innerhalb der Matrix auf den gleichen Anfangswert initialisiert wird?

EDIT

Basierend auf einem Kommentar von user657267 sagte er:

Beachten Sie, dass technisch können Sie nicht auf ein Gewerkschaftsmitglied schreiben und lesen von einem anderen

Bedenken Sie Folgendes: ohne Änderungen an der obigen Klasse vorzunehmen und einfach diese Operatorüberladung hinzuzufügen:

std::ostream& operator<<(std::ostream& out, const SomeClass& s) {  
    out << std::endl; 

    out << "{Box, Slice, Row, Column}\n"; 
    for (unsigned box = 0; box < 4; box++) { 
     for (unsigned slice = 0; slice < 4; slice++) { 
      for (unsigned row = 0; row < 4; row++) { 
       for (unsigned col = 0; col < 4; col++) { 
        out << "(" << box << "," << slice << "," << row << "," << col << ") = " 
         << s.m_4[box][slice][row][col] << std::endl; 
       } 
      } 
     } 
    } 
    return out; 
} // operator<< 

Jetzt in der Hauptfunktion können wir dies tun.

int main() { 
    SomeClass s; 

    // Initialize This Array To Have Each Value Incremented From 0 - 255 
    for (unsigned u = 0; u < 256; u++) { 
     s.m_256[u] = u; 
    } 

    // Print Out Our Array That Is In The Union Using The Overloaded Operator. 
    // Note The Overloaded Operator Is Using The declaration of m_p4 and not m_p256 
    std::cout << s << std::endl; 

    // Now We Know That If You Extract A Value From Any Given Index It Will Return That Value. 
    // So Lets Pull Out Two Random Values From Using The Other Two Members of the Union. 
    int A = s.m_4[0][2][1][3]; 
    int B = s.m_16[12][9]; 

    // Now Print Out A & B 
    std::cout << A << ", " << B << std::endl; 

    return 0; 
} 

Andere als die gedruckte Array Tabelle die letzten beiden Werte sind:

39, 201 

Nun, wenn wir durch den Tisch blättern und suchen (0,2,1,3) der Wert ist 39 und um zu testen, ob 201 korrekt ist; wir haben [12] [9] benutzt. Wenn Sie eine doppelte for-Schleife verwenden, um ein flaches Array zu indizieren, ist die Indizierung gleich (i * num_j + j), also können wir, wenn wir wissen, dass die 2D-Array-Version dieses 1D- oder 4D-Arrays [16] [16] ist berechne diesen Wert mathematisch: 12 * 16 + 9 = 201.

In meinem speziellen Fall macht dies nicht seine Aussage ungültig? In C++ sind Gewerkschaften nicht die gemeinsame Nutzung von Speicher zwischen zwei Variablen, und wenn Sie den gleichen Datentyp wie int haben & int dies macht sie nicht Alias ​​voneinander? Ich war sicherlich in der Lage, das 1D-Flat-Array zu initialisieren, die 4D-Version zum Drucken einer Tabelle zu verwenden und konnte Werte aus beiden 2D-Versionen extrahieren.

bearbeiten

Ich weiß, was andere sagen Sie nicht, weil der Fall als solche auf ein und Zugriff auf andere technisch schreiben:

union foo { 
    int x; 
    char y; 
}; 

hier eine ausgezeichnete Antwort auf a andere Frage zu Gewerkschaften Difference Between Structs & Unions. In meinem Fall sind jedoch der Datentyp und die Speichergröße für alle drei Arrays identisch.Wenn ein Wert in einem geändert wird, erwarte ich auch, dass er sich in einem anderen ändert. Dies sind nur verschiedene Möglichkeiten, um auf denselben Speicher zuzugreifen. Schließlich wird diese "namenlose Union" ein privates Mitglied innerhalb meiner Klasse sein, und es wird öffentliche Methoden geben, um eine Konstante const auf das gesamte Array zu erhalten, um die Inhalte von den Arrays durch Indexwerte von jedem der 3 Typen und zu beziehen Platzieren Sie den Inhalt mit einem der drei Typen in das Array.

Alle Kesselplatte wird hinter den Kulissen im privaten erfolgen. Also sehe ich das nicht als in Frage, und das Verhalten hier ist das, wonach ich bin. Es ist nicht so, als würde ich eine Instanz einer Union erstellen, in der es gemischte Typen gibt. Ich mache keine kleinen Felder mit ihnen. Ich spare im Grunde Speicher, so dass ich nicht 3 Arrays haben muss, die 256 x (Größe des Elements) dann eine Reihe von Kopieren von einem Array zu einem anderen Array Semantik haben, diese Eigenschaft, wie Gewerkschaften funktionieren, ist was Ich bin eigentlich danach. Es ist 1/3 der Speichermenge, die von einer einzelnen Instanz der Klasse verwendet wird, wahrscheinlich 20% schneller und effizienter, ohne dass drei verschiedene unabhängige Arrays jedes Mal synchronisiert werden müssen, wenn ein Element hinzugefügt oder entfernt oder innerhalb des Arrays verschoben wird .

As Strukturen definiert sind: Sie werden genug Speicher für jeden Datentyp und Instanz innerhalb der Struktur zuordnen. Sie können jeden Datentyp unabhängig festlegen

Als Unions definiert sind: Sie reservieren genügend Speicher für den größten Datentyp innerhalb der Union. Wenn Sie einen Datentyp festlegen, ändert sich der andere Datentyp.

Im Zusammenhang mit meiner Klasse ist die Union namenlos, so dass Sie keine Instanz davon erstellen können, jedoch können Sie auf alle Mitglieder zugreifen. In dem Fall hier mit diesen drei Arrays:

byte a[256];   // 256 bytes 
byte b[16][16];  // 16 x 16 = 256 bytes 
byte c[4][4][4][4]; // 4^4 = 256 bytes 

Sie sind genau die gleiche Größe; und in meinem sind alle drei das gleiche Array in meiner Klasse. Dies wird verwendet, um auf die Daten auf verschiedene Arten zuzugreifen.

Answer 1

Die Schleife ist sicherlich ein übertrieben:

std::fill(std::begin(m_256), std::end(m_256), 42); // fills with 42 

Andere als die, keine eingebauten Sprachkonstrukt; es würde ungefähr so ​​viel wie oben sein.