C++ => Skriv nyckelord

klass

Introducerar definitionen av klasstypen.

class foo {
    int x;
  public:
    int get_x();
    void set_x(int new_x);
};

Presenterar en utarbetad typspecifikation som anger att följande namn är namnet på en klasstyp. Om klassnamnet redan har deklarerats kan det hittas även om det är dolt av ett annat namn. Om klassnamnet inte redan har deklarerats förklaras det framåt.

class foo; // elaborated type specifier -> forward declaration
class bar {
  public:
    bar(foo& f);
};
void baz();
class baz; // another elaborated type specifer; another forward declaration
           // note: the class has the same name as the function void baz()
class foo {
    bar b;
    friend class baz; // elaborated type specifier refers to the class,
                      // not the function of the same name
  public:
    foo();
};

Introducerar en typparameter i deklarationen av en mall .

template <class T>
const T& min(const T& x, const T& y) {
    return b < a ? b : a;
}

I deklarationen av en mall mall parameter , nyckelordet class föregår namnet på parametern. Eftersom argumentet för en mallmallparameter endast kan vara en klassmall, är användningen av class här överflödigt. Grammatiken i C ++ kräver dock det.
```
template <template <class T> class U>
//                           ^^^^^ "class" used in this sense here;
//                                 U is a template template parameter
void f() {
    U<int>::do_it();
    U<double>::do_it();
}
```

Observera att känsla 2 och känsla 3 kan kombineras i samma förklaring. Till exempel:

template <class T>
class foo {
};

foo<class bar> x; // <- bar does not have to have previously appeared.

C ++ 11

I deklarationen eller definitionen av ett enum förklarar enum att vara en scoped enum .
```
enum class Format {
    TEXT,
    PDF,
    OTHER,
};
Format f = F::TEXT;
```

struct

Utbytbara med class , förutom följande skillnader:

Om en typ klass definieras med nyckelordet struct , kommer standard tillgängligheten av baser och medlemmar är public snarare än private .
struct kan inte användas för att deklarera en parametertyp för malltyp eller mallmallparameter; bara class kan.

enum

Presenterar definitionen av en uppräkningstyp .

enum Direction {
    UP,
    LEFT,
    DOWN,
    RIGHT
};
Direction d = UP;

C ++ 11

I C ++ 11 kan enum eventuellt följas av class eller struct att definiera en scoped enum . Vidare kan både scoped och unscoped-enums ha sin underliggande typ uttryckligen specificerad av : T följer enum-namnet, där T refererar till en heltalstyp.

   enum class Format : char {
       TEXT,
       PDF,
       OTHER
   };
   Format f = Format::TEXT;

   enum Language : int {
       ENGLISH,
       FRENCH,
       OTHER
   };

Enumeratorer i normala enum kan också föregås av omfattningsoperatören, även om de fortfarande anses vara inom räckvidden som enum definierades i.

   Language l1, l2;

   l1 = ENGLISH;
   l2 = Language::OTHER;

Introducerar en utarbetad typspecifikation som anger att följande namn är namnet på en tidigare förklarad enumtyp. (En utarbetad typspecifikation kan inte användas för att vidarebefordra en enumtyp.) Enum kan namnges på detta sätt även om den är dold av ett annat namn.
```
enum Foo { FOO };
void Foo() {}
Foo foo = FOO;      // ill-formed; Foo refers to the function
enum Foo foo = FOO; // ok; Foo refers to the enum type
```

C ++ 11

Införar en ogenomskinlig enumdeklaration som förklarar enum utan att definiera den. Det kan antingen förklara ett tidigare deklarerat enum, eller framlänga ett enum som inte tidigare har deklarerats.
Ett enum som först förklarades som scoped kan inte senare förklaras som unscoped, eller vice versa. Alla deklarationer av enum måste överensstämma med underliggande typ.
Vid framåtdeklaration av en icke-kodad enum måste den underliggande typen uttryckligen anges, eftersom det inte kan uttalas förrän värdena för uppräknare är kända.
```
enum class Format; // underlying type is implicitly int
void f(Format f);
enum class Format {
    TEXT,
    PDF,
    OTHER,
};

enum Direction;    // ill-formed; must specify underlying type
```

union

Introducerar definitionen av en facklig typ.

// Example is from POSIX
union sigval {
    int     sival_int;
    void   *sival_ptr;
};

Introducerar en utarbetad typspecifikation som anger att följande namn är namnet på en unionstyp. Om fackföreningsnamnet redan har deklarerats kan det hittas även om det är dolt av ett annat namn. Om fackföreningsnamnet inte redan har förklarats, förklaras det framåt.

union foo; // elaborated type specifier -> forward declaration
class bar {
  public:
    bar(foo& f);
};
void baz();
union baz; // another elaborated type specifer; another forward declaration
           // note: the class has the same name as the function void baz()
union foo {
    long l;
    union baz* b; // elaborated type specifier refers to the class,
                  // not the function of the same name
};

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

C++
Skriv nyckelord

Sök…

klass

struct

enum

union