Conversion est quand une valeur est , um, converti en un type différent. Le résultat est une valeur du type cible, et il y a des règles pour quelle valeur de sortie résulte de quelle entrée (du type source).
Par exemple:
int i = 3;
unsigned int j;
j = i; // the value of "i" is converted to "unsigned int".
Le résultat est la valeur unsigned int
qui est égale à i
modulo UINT_MAX+1
, et cette règle fait partie de la langue. Donc, dans ce cas, la valeur (en anglais) est toujours "3", mais c'est une valeur int non signée de 3, qui est subtilement différente d'une valeur int signée de 3.
Notez que la conversion est automatique. utilisé une valeur int signée dans une position où une valeur int non signée est requise, et la langue définit ce que cela signifie sans que nous disions réellement que nous sommes en train de convertir. C'est ce qu'on appelle une "conversion implicite".
"Coulée" est une conversion explicite.
Par exemple:
unsigned int k = (unsigned int)i;
long l = long(i);
unsigned int m = static_cast<unsigned int>(i);
sont tous les moulages. Spécifiquement, selon 5.4/2 de la norme, k
utilise une cast-expression, et selon 5.2.3/1, l
utilise une chose équivalente (sauf que j'ai utilisé un type différent). m
utilise un "opérateur de conversion de type" (static_cast
), mais d'autres parties de la norme se réfèrent également à celles-ci en tant que "moulages".
types définis par l'utilisateur peuvent définir des "fonctions de conversion" qui fournissent des règles spécifiques pour convertir votre type à un autre type, et les constructeurs mono-arg sont utilisés dans les conversions aussi:
struct Foo {
int a;
Foo(int b) : a(b) {} // single-arg constructor
Foo(int b, int c) : a(b+c) {} // two-arg constructor
operator float() { return float(a); } // conversion function
};
Foo f(3,4); // two-arg constructor
f = static_cast<Foo>(4); // conversion: single-arg constructor is called
float g = f; // conversion: conversion function is called
+1, mais il convient de noter que cette terminologie n'est pas strictement respectée. Considérez 'int i; float f = static_cast (i) '- par votre logique (et je suis d'accord), c'est une * conversion *, pas une distribution. C++ utilise toujours 'static_cast' (et oui, je suis conscient qu'une conversion implicite fonctionnerait ici). En d'autres termes: vous avez donné la distinction sémantiquement la plus significative des deux termes. Mais C++ ne suit pas cette distinction. –
Edité pour clarifier certaines choses, j'espère que je ne répandrai pas de désinformation. –
Vous semblez dire qu'une * expression-cast * (5.4/2) n'est pas un cast, mais plutôt une conversion. Cela peut être une définition utile de "cast" contre "conversion" pour les langages de programmation en général, mais ce n'est pas la définition de "cast" utilisée dans la norme C++. –