C++
Typedef en type aliassen

Invoering

Syntaxis

• typedef type-specifier-seq init-declarator-lijst ;
• attribuut-specificatie-seq typedef DEC -specificatie-seq init-declarator-lijst ; // sinds C ++ 11
• met behulp van identifier attribute-specifier-seq ( opt ) = type-id ; // sinds C ++ 11

Basic typedef syntaxis

Een typedef declaratie heeft dezelfde syntaxis als een variabele of functiedeclaratie, maar bevat het woord typedef . De aanwezigheid van typedef zorgt ervoor dat de verklaring een type typedef plaats van een variabele of functie.

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"

Nadat een type-alias is gedefinieerd, kan deze uitwisselbaar worden gebruikt met de oorspronkelijke naam van het type.

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

typedef nooit een bepaald type. Het geeft alleen een andere manier om naar een bestaand type te verwijzen.

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

Meer complex gebruik van typedef

De regel dat typedef aangiften dezelfde syntaxis hebben als gewone variabele- en functieverklaringen, kan worden gebruikt om complexere aangiften te lezen en te schrijven.

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"

Dit is vooral handig voor constructies met verwarrende syntaxis, zoals verwijzingen naar niet-statische leden.

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"

Het is moeilijk om de syntaxis van de volgende functieverklaringen te onthouden, zelfs voor ervaren programmeurs:

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

typedef kan worden gebruikt om ze gemakkelijker te lezen en te schrijven:

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

Meerdere typen declareren met typedef

Het sleutelwoord typedef is een specificator, dus het is afzonderlijk van toepassing op elke declarator. Daarom verwijst elke gedeclareerde naam naar het type dat die naam zou hebben zonder 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(*)()

Aliasverklaring met "gebruiken"

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