C++
Typedef e digita alias

introduzione

Sintassi

• typedef type-specificatore-seq init-declarator-list ;
• attributo-specificatore-seq typedef decl-specifier-seq init-declarator-list ; // dal C ++ 11
• using identifier attribute-specifier-seq ( opt ) = type-id ; // dal C ++ 11

Sintassi typedef di base

Una dichiarazione typedef ha la stessa sintassi di una dichiarazione di variabile o funzione, ma contiene la parola typedef . La presenza di typedef fa sì che la dichiarazione dichiari un tipo invece di una variabile o funzione.

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"

Una volta definito un alias di tipo, può essere utilizzato in modo intercambiabile con il nome originale del tipo.

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

typedef non crea mai un tipo distinto. Dà solo un altro modo di riferirsi a un tipo esistente.

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

Usi più complessi di typedef

La regola che le dichiarazioni typedef hanno la stessa sintassi delle dichiarazioni di variabili e funzioni ordinarie può essere utilizzata per leggere e scrivere dichiarazioni più complesse.

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"

Ciò è particolarmente utile per i costrutti con sintassi confusa, come i puntatori ai membri non statici.

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"

È difficile ricordare la sintassi delle seguenti dichiarazioni di funzione, anche per i programmatori esperti:

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

typedef può essere usato per renderli più facili da leggere e scrivere:

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

Dichiarazione di più tipi con typedef

La parola chiave typedef è un identificatore, quindi si applica separatamente a ciascun dichiarante. Pertanto, ogni nome dichiarato si riferisce al tipo che quel nome avrebbe in assenza di 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(*)()

Dichiarazione alias con "utilizzo"

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