C++
Typedef- und Typ-Aliase

Einführung

Syntax

• typedef Typspezifizierer-seq- Init-Deklaratorliste ;
• attributspezifizierer-seq typedef deklarationsbezeichner- seq init-deklaratorliste ; // seit C ++ 11
• Verwendung Identifikator attribute-Spezifizierer-Seq (opt) = type-ID; // seit C ++ 11

Grundlegende Typedef-Syntax

Eine typedef Deklaration hat dieselbe Syntax wie eine Variablen- oder Funktionsdeklaration, enthält jedoch das Wort typedef . Das Vorhandensein von typedef bewirkt, dass die Deklaration einen Typ anstelle einer Variablen oder Funktion deklariert.

int T;         // T has type int
typedef int T; // T is an alias for int

int A[100];         // A has type "array of 100 ints"
typedef int A[100]; // A is an alias for the type "array of 100 ints"

Nachdem ein Typalias definiert wurde, kann er austauschbar mit dem ursprünglichen Namen des Typs verwendet werden.

typedef int A[100];
// S is a struct containing an array of 100 ints
struct S {
    A data;
};

typedef erstellt niemals einen eigenen Typ. Es gibt nur eine andere Möglichkeit, auf einen vorhandenen Typ zu verweisen.

struct S {
    int f(int);
};
typedef int I;
// ok: defines int S::f(int)
I S::f(I x) { return x; }

Komplexere Anwendungen von Typedef

Die Regel, dass typedef Deklarationen dieselbe Syntax wie gewöhnliche Variablen haben, und Funktionsdeklarationen können zum Lesen und Schreiben komplexer Deklarationen verwendet werden.

void (*f)(int);         // f has type "pointer to function of int returning void"
typedef void (*f)(int); // f is an alias for "pointer to function of int returning void"

Dies ist besonders nützlich für Konstrukte mit einer verwirrenden Syntax, z. B. Zeiger auf nicht statische Member.

void (Foo::*pmf)(int);         // pmf has type "pointer to member function of Foo taking int
                               // and returning void"
typedef void (Foo::*pmf)(int); // pmf is an alias for "pointer to member function of Foo
                               // taking int and returning void"

Die Syntax der folgenden Funktionsdeklarationen ist selbst für erfahrene Programmierer schwer zu merken:

void (Foo::*Foo::f(const char*))(int);
int (&g())[100];

typedef kann verwendet werden, um das Lesen und Schreiben zu erleichtern:

typedef void (Foo::pmf)(int);  // pmf is a pointer to member function type
pmf Foo::f(const char*);       // f is a member function of Foo

typedef int (&ra)[100];        // ra means "reference to array of 100 ints"
ra g();                        // g returns reference to array of 100 ints

Mehrere Typen mit typedef deklarieren

Das Schlüsselwort typedef ist ein typedef , es gilt also für jeden Deklarator. Daher bezieht sich jeder deklarierte Name auf den Typ, den dieser Name ohne typedef .

int *x, (*p)();         // x has type int*, and p has type int(*)()
typedef int *x, (*p)(); // x is an alias for int*, while p is an alias for int(*)()

Alias-Deklaration mit "using"

using I = int;
using A = int[100];             // array of 100 ints
using FP = void(*)(int);        // pointer to function of int returning void
using MP = void (Foo::*)(int);  // pointer to member function of Foo of int returning void