C++
Typedef et alias de type

Introduction

Syntaxe

• typedef type-specifier-seq liste init-déclarator ;
• attribut-spécificateur-seq typedef décl-spécificateur-seq liste init-déclarateur ; // depuis C ++ 11
• en utilisant l' identificateur attribut-spécificateur-seq ( opt ) = id-type ; // depuis C ++ 11

Syntaxe de base de typedef

Une déclaration typedef a la même syntaxe qu'une déclaration de variable ou de fonction, mais elle contient le mot typedef . La présence de typedef fait que la déclaration déclare un type au lieu d'une variable ou d'une fonction.

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"

Une fois qu'un alias de type a été défini, il peut être utilisé indifféremment avec le nom d'origine du type.

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

typedef ne crée jamais un type distinct. Cela ne donne qu'une autre façon de faire référence à un type existant.

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

Utilisations plus complexes du typedef

La règle selon laquelle les déclarations typedef ont la même syntaxe que les déclarations de variables et de fonctions ordinaires peut être utilisée pour lire et écrire des déclarations plus complexes.

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"

Ceci est particulièrement utile pour les constructions avec une syntaxe confuse, telles que les pointeurs vers les membres non statiques.

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"

Il est difficile de se souvenir de la syntaxe des déclarations de fonctions suivantes, même pour les programmeurs expérimentés:

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

typedef peut être utilisé pour faciliter leur lecture et leur écriture:

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

Déclarer plusieurs types avec typedef

Le mot-clé typedef est un spécificateur, il s'applique donc séparément à chaque déclarant. Par conséquent, chaque nom déclaré fait référence au type que ce nom aurait en l'absence de 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(*)()

Déclaration d'alias avec "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