Recherche…


int

Indique un type entier signé avec "la taille naturelle suggérée par l'architecture de l'environnement d'exécution", dont la plage inclut au moins -32767 à +32767 inclus.

int x = 2;
int y = 3;
int z = x + y;

Peut être combiné avec unsigned , short , long et long long (qv) pour donner d'autres types d'entiers.

bool

Un type entier dont la valeur peut être true ou false .

bool is_even(int x) {
    return x%2 == 0;
}
const bool b = is_even(47); // false

carboniser

Un type d'entier qui est "assez grand pour stocker n'importe quel membre du jeu de caractères de base de l'implémentation". Elle est mise en oeuvre définie si char est signé (et a une plage d'au moins -127 à 127, inclusivement) ou non signé (et a une plage d'au moins 0 à 255, inclusivement).

const char zero = '0';
const char one = zero + 1;
const char newline = '\n';
std::cout << one << newline; // prints 1 followed by a newline

char16_t

C ++ 11

Un type d'entier non signé de même taille et de même alignement que uint_least16_t , qui est donc assez grand pour contenir une unité de code UTF-16.

const char16_t message[] = u"你好,世界\n";            // Chinese for "hello, world\n"
std::cout << sizeof(message)/sizeof(char16_t) << "\n"; // prints 7

char32_t

C ++ 11

Un type entier non signé de la même taille et du même alignement que uint_least32_t , donc suffisamment grand pour contenir une unité de code UTF-32.

const char32_t full_house[] = U"🂣🂳🂨🂸🃈";               // non-BMP characters
std::cout << sizeof(full_house)/sizeof(char32_t) << "\n"; // prints 6

flotte

Un type à virgule flottante. Possède la plage la plus étroite parmi les trois types de virgule flottante en C ++.

float area(float radius) {
    const float pi = 3.14159f;
    return pi*radius*radius;
}

double

Un type à virgule flottante. Sa portée comprend celle du float . Lorsqu'il est combiné avec long , désigne le long double virgule flottante, dont l'intervalle inclut celui du double .

double area(double radius) {
    const double pi = 3.141592653589793;
    return pi*radius*radius;
}

longue

Indique un type entier signé qui est au moins aussi long que int et dont l'intervalle inclut au moins -2147483647 à +2147483647 inclus (c'est-à-dire - (2 ^ 31 - 1) à + (2 ^ 31 - 1)). Ce type peut également être écrit en tant que long int .

const long approx_seconds_per_year = 60L*60L*24L*365L;

La combinaison long double dénote un type à virgule flottante, qui a la plus grande portée parmi les trois types à virgule flottante.

long double area(long double radius) {
    const long double pi = 3.1415926535897932385L;
    return pi*radius*radius;
}
C ++ 11

Lorsque la long spécificateur se produit deux fois, comme au long long , il désigne un type entier signé qui est au moins aussi longue que long , et dont la portée comprend au moins -9223372036854775807 à 9223372036854775807 inclusivement (qui est, - (2 ^ 63 - 1) à + (2 ^ 63-1)).

// support files up to 2 TiB
const long long max_file_size = 2LL << 40;

court

Indique un type d'entier signé qui est au moins aussi long que char et dont l'intervalle inclut au moins -32767 à +32767 inclus. Ce type peut également être écrit en tant que short int .

// (during the last year)
short hours_worked(short days_worked) {
    return 8*days_worked;
}

vide

Un type incomplet; Il n'est pas possible qu'un objet soit de type void , ni de tableau void ou de références à void . Il est utilisé comme type de retour des fonctions qui ne renvoient rien.

De plus, une fonction peut être redondée avec un seul paramètre de type void ; Cela équivaut à déclarer une fonction sans paramètre (par exemple, int main() et int main(void) déclarent la même fonction). Cette syntaxe est autorisée pour la compatibilité avec C (où les déclarations de fonctions ont un sens différent de celui de C ++).

Le type void* ("pointer to void ") a la propriété que tout pointeur d'objet peut être converti en lui et en retour et aboutir au même pointeur. Cette fonctionnalité rend le type void* adapté à certains types d’interfaces d’effacement de type (de type non sécurisé), par exemple pour des contextes génériques dans les API de style C (par exemple, qsort , pthread_create ).

Toute expression peut être convertie en une expression de type void ; cela s'appelle une expression à valeur rejetée :

static_cast<void>(std::printf("Hello, %s!\n", name));  // discard return value

Cela peut être utile pour signaler explicitement que la valeur d'une expression n'est pas intéressante et que l'expression doit être évaluée pour ses seuls effets secondaires.

wchar_t

Un type entier suffisamment grand pour représenter tous les caractères du plus grand jeu de caractères étendu pris en charge, également appelé jeu de caractères larges. (Il n'est pas portable de supposer que wchar_t utilise un encodage particulier, tel que UTF-16.)

Il est normalement utilisé lorsque vous devez stocker des caractères sur ASCII 255, car sa taille est supérieure à celle du caractère de type char .

const wchar_t message_ahmaric[] = L"ሰላም ልዑል\n"; //Ahmaric for "hello, world\n"
const wchar_t message_chinese[] = L"你好,世界\n";// Chinese for "hello, world\n"
const wchar_t message_hebrew[]  = L"שלום עולם\n"; //Hebrew for "hello, world\n"
const wchar_t message_russian[] = L"Привет мир\n";  //Russian for "hello, world\n"
const wchar_t message_tamil[]   = L"ஹலோ உலகம்\n"; //Tamil for "hello, world\n"


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow