Sök…


Introduktion

typedef och (sedan C ++ 11) using nyckelord kan användas för att ge ett nytt namn till en befintlig typ.

Syntax

  • typedef typ-specificier-seq init-declarator-list ;
  • attribut-specifier-seq typedef decl-specifier-seq init-declarator-list ; // sedan C ++ 11
  • med hjälp av identifierare attribut-specifier-seq ( opt ) = typ-id ; // sedan C ++ 11

Grundläggande typedef-syntax

En typedef deklaration har samma syntax som en variabel eller funktionsdeklaration, men den innehåller ordet typedef . Närvaron av typedef gör att deklarationen deklarerar en typ istället för en variabel eller funktion.

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"

När ett typalias har definierats kan det användas omväxlande med typens ursprungliga namn.

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

typedef skapar aldrig en distinkt typ. Det ger bara ett annat sätt att hänvisa till en befintlig typ.

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

Mer komplex användning av typedef

Regeln om att typedef deklarationer har samma syntax som vanliga variabel- och funktionsdeklarationer kan användas för att läsa och skriva mer komplexa deklarationer.

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"

Detta är särskilt användbart för konstruktioner med förvirrande syntax, till exempel pekare på icke-statiska medlemmar.

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"

Det är svårt att komma ihåg syntaxen för följande funktionsdeklarationer, även för erfarna programmerare:

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

typedef kan användas för att göra dem lättare att läsa och skriva:

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

Förklarar flera typer med typedef

Nyckelordet typedef är en specifikator, så det gäller separat för varje deklarator. Därför hänvisar varje deklarerat namn till den typ som namnet skulle ha i frånvaro av 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(*)()

Aliasdeklaration med "använder"

C ++ 11

Syntaxen för att using är mycket enkel: namnet som ska definieras går på vänster sida och definitionen går på höger sida. Du behöver inte skanna för att se var namnet är.

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

Att skapa ett typalias med att using har exakt samma effekt som att skapa ett typedef med typedef . Det är helt enkelt en alternativ syntax för att åstadkomma samma sak.

Till skillnad från typedef kan using typedef . En "mall typedef" skapad med using kallas en aliasmall .



Modified text is an extract of the original Stack Overflow Documentation
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow