C++ => litteraler

Introduktion

Traditionellt sett är ett bokstavligt uttryck som betecknar en konstant vars typ och värde framgår av dess stavning. Till exempel är 42 en bokstavlig, medan x inte är eftersom man måste se sin förklaring för att känna till sin typ och läsa tidigare kodrader för att veta dess värde.

Emellertid har C ++ 11 också lagt till användardefinierade bokstäver , som inte är bokstäver i traditionell mening men kan användas som en kortfattning för funktionssamtal.

Sann

Ett nyckelord som anger ett av de två möjliga värdena för typ bool .

bool ok = true;
if (!f()) {
    ok = false;
    goto end;
}

falsk

Ett nyckelord som anger ett av de två möjliga värdena för typ bool .

bool ok = true;
if (!f()) {
    ok = false;
    goto end;
}

nullptr

C ++ 11

Ett nyckelord som anger en nollpekarkonstant. Den kan konverteras till vilken som helst pekare eller pekare-till-medlemstyp, vilket ger en nollpekare av den resulterande typen.

Widget* p = new Widget();
delete p;
p = nullptr; // set the pointer to null after deletion

Observera att nullptr inte själv är en pekare. Typen av nullptr är en grundläggande typ som kallas std::nullptr_t .

void f(int* p);

template <class T>
void g(T* p);

void h(std::nullptr_t p);

int main() {
    f(nullptr); // ok
    g(nullptr); // error
    h(nullptr); // ok
}

detta

Inom en medlemsfunktion i en klass är nyckelordet this en pekare till förekomsten av klassen som funktionen kallades till. this kan inte användas i en statisk medlemsfunktion.

struct S {
    int x;
    S& operator=(const S& other) {
        x = other.x;
        // return a reference to the object being assigned to
        return *this;
    }
};

Typen av this beror på cv-kvalificeringen av medlemsfunktionen: om X::f är const , är typen av this inom f const X* , så this kan inte användas för att modifiera icke-statiska datamedlemmar från en const medlemsfunktion. På this ärver detta volatile kvalifikation från den funktion den visas i.

C ++ 11

this kan också användas i en stag-eller-lika initialisator för en icke-statisk datamedlem.

struct S;
struct T {
    T(const S* s);
    // ...
};
struct S {
    // ...
    T t{this};
};

this är en rvalue, så det kan inte tilldelas.

Heltal bokstavligt

Ett heltal bokstavligt är ett primärt uttryck för formen

decimal-literal

Det är en decimal som inte är noll (1, 2, 3, 4, 5, 6, 7, 8, 9) följt av noll eller fler decimaler (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

int d = 42;

oktal-literal

Det är siffran noll (0) följt av noll eller fler oktala siffror (0, 1, 2, 3, 4, 5, 6, 7)

int o = 052

hex-literal

Det är karaktersekvensen 0x eller karaktersekvensen 0X följt av en eller flera hexadecimala siffror (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C d, D, e, E, f, F)

int x = 0x2a; int X = 0X2A;

binär-bokstavlig (sedan C ++ 14)

Det är karaktärsekvensen 0b eller karaktärsekvensen 0B följt av en eller flera binära siffror (0, 1)

int b = 0b101010; // C++14

Heltalssuffix, om det tillhandahålls, kan innehålla ett eller båda av följande (om båda tillhandahålls kan de visas i valfri ordning:

unsigned-suffix (tecknet u eller tecknet U)

unsigned int u_1 = 42u;

long-suffix (karaktären l eller karaktären L) eller the long-long-suffixet (karaktärsekvensen ll eller karaktärsekvensen LL) (sedan C ++ 11)

Följande variabler initialiseras också till samma värde:

unsigned long long l1 = 18446744073709550592ull; // C++11
unsigned long long l2 = 18'446'744'073'709'550'592llu; // C++14
unsigned long long l3 = 1844'6744'0737'0955'0592uLL; // C++14
unsigned long long l4 = 184467'440737'0'95505'92LLU; // C++14

anteckningar

Bokstäver i heltalslitteralerna är känsliga för versaler: 0xDeAdBaBeU och 0XdeadBABEu representerar samma nummer (ett undantag är det långa-långa suffixet, som är antingen ll eller LL, aldrig lL eller Ll)

Det finns inga negativa heltalslitteraler. Uttryck som -1 tillämpar operatorn unary minus på det värde som representeras av det bokstavliga, vilket kan involvera implicita typomvandlingar.

I C före C99 (men inte i C ++) tillåts icke-blandade decimalvärden som inte passar in i lång int att ha typen osignerad lång int.

När de används i ett kontrollerande uttryck för #if eller #elif fungerar alla signerade heltalskonstanter som om de har typen std :: intmax_t och alla osignerade heltalskonstanter fungerar som om de har typen std :: uintmax_t.

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

C++
litteraler

Sök…