aligned-Pragma

Mit dem aligned-Pragma können die Datenelemente innerhalb von Klassen, Strukturen und Unions auf eine größere Anzahl Bytes ausgerichtet werden, als in der standardmäßigen Minimal-Ausrichtung durch den Compiler vorgesehen ist.

Das Pragma kann in allen Sprachmodi des Compilers verwendet werden.

#pragma aligned n

n gibt eine Anzahl Bytes in Zweierpotenzen bis maximal 8 an. n kann als Dezimal-, Oktal- oder Sedezimalzahl angegeben werden. Zulässige Angaben (dezimal) sind 1, 2, 4, 8 und 16 (syntaktisch noch erlaubt) Byte.

Hinweise

Zur Vereinfachung wird im Folgenden nur noch von Strukturen gesprochen. Die Hinweise gelten sinngemäß auch für Klassen und Unions.

• Pragmas, die weniger Bytes angeben als für die Minimal-Ausrichtung des entsprechenden Datentyps vorgesehen (siehe Tabelle unten), sind nicht zulässig und werden ignoriert.

  Datentyp	Minimal-Ausrichtung (Anzahl Bytes)
  char	1
  short	2
  int	4
  long	4
  long long	8
  float	4
  Zeiger	4
  double	8
  long double	8

• Das auszurichtende Datenelement kann auch vom Typ Bitfeld sein. In diesem Fall wird das Bitfeld in einem neuen Basisfeld mit der angeforderten Ausrichtung angelegt.

• Bei static-Elementen wird das Pragma ignoriert.

• Das Pragma muss innerhalb der Strukturdefinition unmittelbar vor dem auszurichtenden Datenelement stehen. An anderer Stelle wird es ignoriert.

• Stehen mehrere Pragmas vor einem Datenelement, wird dasjenige mit der größten Ausrichtungsangabe berücksichtigt.

• Steht ein Pragma vor der Deklaration mehrerer Strukturelemente, bezieht es sich nur auf das erste deklarierte Element.

• Die Ausrichtung einer Struktur richtet sich nach der maximalen Ausrichtung ihrer Elemente.

• Tritt eine Struktur als Element einer anderen Struktur auf, bezieht sich das davorstehende Pragma auf die Ausrichtung der Gesamtstruktur, nicht auf die Ausrichtung ihrer Elemente.

• Ein Pragma vor einem Strukturelement vom Typ Array bezieht sich auf die Ausrichtung des gesamten Arrays (also auf das erste Arrayelement), nicht auf die übrigen Arrayelemente.

• aligned-Pragma und pack-Pragma (siehe "pack-Pragma") können gleichzeitig für ein bestimmtes Strukturelement aktiv sein. In diesem Fall hat das aligned-Pragma Vorrang.

Beispiel

... 
class bsp1 
  {
    int a;                  // Ausrichtung auf 4 Bytes. 
#pragma aligned 8 
    int b,c;                // b wird auf 8 Bytes ausgerichtet. 
                            // c wird auf 4 Bytes ausgerichtet. 
                            // Die maximale Ausrichtung eines Elements
                            // der Klasse bsp1 beträgt daher 8 Bytes.
                            // Die Klasse bsp1 wird daher auf 8 Bytes
                            // ausgerichtet.
    int d;                  // Ausrichtung auf 4 Bytes. 
  };
class bsp2 
  {
public: 
    double dens;            // Ausrichtung auf 8 Bytes. 
#pragma aligned 4           // Wird ignoriert. Da die maximale Ausrichtung
                            // eines Elements der Struktur stru1 8 Bytes
                            // beträgt, wird auch stru1 auf 8 Bytes
                            // ausgerichtet. Eine entsprechende Warnung
                            // wird ausgegeben.
    struct 
      {
        int istru11;        // Ausrichtung auf 4 Bytes. 
        double dstru12;     // Ausrichtung auf 8 Bytes. 
      } stru1;              // Ausrichtung auf 8 Bytes (s.o.). 
    struct 
      { 
        short s1;           // Ausrichtung auf 2 Bytes. 
        short s2;           // Ausrichtung auf 2 Bytes. 
      } stru2;              // Wird auf 2 Bytes ausgerichtet, da die maximale
                            // Ausrichtung eines Elements 2 Bytes beträgt.
#pragma aligned 4 
    char c;                 // Ausrichtung auf 4 Bytes.
    char c1;                // Ausrichtung auf 1 Byte.
#pragma aligned 8 
    short ar1[16];          // Das Array wird auf 8 Bytes ausgerichtet,
                            // nicht jedoch die einzelnen Arrayelemente.
    ... 
  } 
...