Menu

Conversions de type en C ++

type conversions c

Essayez Notre Instrument Pour Éliminer Les Problèmes

Découvrez les différentes conversions de type prises en charge dans C ++.

Nous espérons que vous devriez connaître tous les types de données disponibles en C ++ à partir de nos tutoriels précédents. Parfois, un besoin peut survenir, tel que nous devons convertir un type en un autre. C'est ce qu'on appelle la conversion de type ou la conversion de type.

Dans ce didacticiel, nous aborderons les différentes conversions de type prises en charge en C ++.

comment ajouter des valeurs dans un tableau

=> Cliquez ici pour le cours C ++ gratuit.

Conversions de type en C ++

Ce que vous apprendrez:

Conversions de type

C ++ prend en charge deux types de conversions de type:

  • Conversion de type implicite: La conversion de type implicite est automatique. Il n'y a aucune interférence de l'utilisateur dans ce type de conversion et le compilateur effectue directement la conversion. La conversion est généralement effectuée lorsque dans l'expression il y a plus d'un type de données. Mais généralement, dans ce type de conversion, il existe une possibilité de perte de données, de perte de signes ou de débordement de données.
  • Conversion de type explicite: La conversion de type explicite est définie par l'utilisateur et est normalement appelée «conversion de type». Ici, l'utilisateur lance ou convertit une valeur d'un type de données en un autre en fonction des besoins. Ce type de conversion est plus sûr.

Nous allons maintenant voir les deux types de conversion de type en détail.

Conversion implicite

Dans la conversion implicite, le compilateur effectue les conversions d'un type de données à un autre chaque fois qu'une expression a plus d'un type de données. Afin d'éviter la perte de données, toutes les variables des autres types de données sont converties dans le plus grand type de données. C'est ce qu'on appelle la promotion.

Laissez-nous comprendre la conversion implicite à l'aide d'un exemple de code.

#include using namespace std; int main() { int num = 10; char ch = 'A'; cout<<'10 + 'A' = '<

Le type entier étant le plus grand dans cette expression, la valeur de la variable de caractère «A» est convertie en son équivalent entier, c'est-à-dire la valeur 65 (valeur ASCII). Ainsi, le résultat de l'expression est 75.

Dans l'expression suivante, nous ajoutons un entier et un caractère («a» -> 97), puis affectons le résultat à float. Ainsi, le résultat de l'expression est implicitement converti en float par le compilateur.

Dans la troisième expression, une variable int courte est convertie implicitement en entier.

Noter : En cas de conversions implicites, si le compilateur détecte une perte potentielle de données, il peut alors faire clignoter un avertissement à cet effet.

Conversion explicite

La conversion explicite est également connue sous le nom de «conversion de type», car nous convertissons un type de données en un autre type de données. Ici, les utilisateurs définissent explicitement le casting, contrairement à la conversion implicite où le compilateur effectue la conversion en interne.

Nous pouvons effectuer une conversion explicite de deux manières:

# 1) Utilisation de l'opérateur d'affectation

La conversion ou la conversion de type explicite à l'aide d'un opérateur d'affectation est effectuée avec force. Ici, nous convertissons ou convertissons un type de données en un autre type de données à l'aide de l'opérateur d'affectation.

La syntaxe générale est:

(data type) expression;

L'exemple suivant explique ceci:

#include #include using namespace std; int main() { int sum; double salary = 4563.75; sum = (int)salary + 1000; cout<<'Sum = '<

Comme indiqué dans la sortie, le type vers lequel nous effectuons un cast indique le type final du résultat de l'expression.

Ceci est avantageux car l'utilisateur peut changer le type d'expression selon les exigences.

# 2) Utilisation de Cast Operator

Dans ce type de casting, nous utilisons un «opérateur de cast» qui est un opérateur unaire pour passer d'un type à un autre.

Types de moulage

Nous avons les types de casting suivants en fonction de l'opérateur de casting que nous utilisons:

# 1) Cast statique

La distribution statique est la plus simple parmi toutes les transtypages à l'aide de l'opérateur de distribution . La distribution statique est capable d'effectuer toutes les conversions qui sont effectuées implicitement. Il effectue également des conversions entre les pointeurs de classes liées les unes aux autres (upcast -> de dérivé à base ou downcast -> de base à dérivé).

Outre les conversions listées ci-dessus, la distribution statique est également capable de convertir n'importe quel pointeur en void *.

La distribution statique est la distribution temporelle compilée. Cela signifie qu'aucune vérification n'est effectuée au moment de l'exécution pour voir si la conversion effectuée est valide ou non. Il incombe donc au programmeur de s'assurer que la conversion était sûre et valide.

En d'autres termes, l'utilisateur doit s'assurer que l'objet converti était plein par rapport au type de données de destination.

Nous spécifions une distribution statique comme suit:

static_cast (expression)

Comprenons le cast statique à l'aide d'un exemple.

#include using namespace std; int main() { double df = 3.5 * 3.5 * 3.5; cout<<'Before casting: df = '<
qu'est-ce que la commande grep sous unix

Modifions maintenant le code ci-dessus comme suit:

#include using namespace std; int main() { double df = 3.5 * 3.5 * 3.5; cout<<'Before casting :df = '<

Dans l'exemple ci-dessus, nous avons légèrement modifié le code pour inclure une variable de caractère avec la valeur «A». Ensuite, nous déclarons un pointeur entier et appliquons une conversion statique pour convertir un caractère en pointeur entier.

Lorsque nous compilons ce programme, nous obtenons la sortie suivante.

Dans la fonction «int main ()»:
10:35: erreur: static_cast non valide du type «char *» au type «int *»

Le programme donne une erreur pour la distribution statique effectuée car elle n'est pas valide. Ainsi, la conversion statique ne permet que la conversion ou la conversion de type valide et donne une erreur lorsque nous essayons d'effectuer une conversion de type indésirable.

# 2) Diffusion dynamique

La distribution dynamique est une distribution d'exécution effectuée pour vérifier la validité de la distribution. La conversion dynamique est effectuée uniquement sur les pointeurs de classe et les références. L'expression renvoie une valeur NULL si la conversion échoue.

La distribution dynamique utilise un mécanisme appelé RTTI (identification du type d'exécution) . RTTI rend toutes les informations sur le type de données de l'objet disponibles au moment de l'exécution et n'est disponible que pour les classes qui ont au moins une fonction virtuelle (type polymorphe). RTTI permet de déterminer le type d'objet au moment de l'exécution ou au moment de l'exécution.

Essayons un exemple pour comprendre la diffusion dynamique.

#include #include using namespace std; class base {public: virtual void print(){}}; class derived:public base{}; int main() { base* b = new derived; derived* d = dynamic_cast(b); if(d != NULL) cout<<'Dynamic_cast done successfully'; else cout<<'Dynamic_cast not successful'; }

Dans ce programme, nous avons défini deux classes, base avec une fonction virtuelle et dérivée ayant une classe de base, base.

meilleur outil de gestion de cas de test pour jira

Dans la fonction main, nous créons un objet de classe dérivé pointé par le pointeur de classe de base. Ensuite, nous exécutons dynamic_cast sur le pointeur de base pointant vers une classe dérivée pour la convertir en un pointeur de classe dérivée.

Comme dans la classe de base, la base est polymorphe (contient une fonction virtuelle), le dynamic_cast réussit.

Remarque: Si nous supprimons la fonction virtuelle de la classe ci-dessus, alors dynamic_cast échouera car les informations RTTI pour les objets ne seront pas disponibles.

La distribution dynamique a une surcharge de sécurité de type au moment de l'exécution.

# 3) Réinterpréter le casting

Ce type de distribution est le plus dangereux à utiliser car il fonctionne sur tout type d'objet sans que les classes soient liées les unes aux autres.

Reintepret_cast fonctionne sur n'importe quel pointeur et il convertit un pointeur de n'importe quel type en n'importe quel autre type, que les pointeurs soient liés les uns aux autres ou non. Il ne vérifie pas si le pointeur ou les données pointées par le pointeur sont identiques ou non.

L'opérateur de conversion ne prend qu'un seul paramètre, le pointeur source vers lequel convertir et ne renvoie aucune valeur. Il convertit simplement le type de pointeur.

Nous ne devons pas utiliser sauf si nécessaire. Nous convertissons généralement le pointeur source en son type d'origine.

Nous utilisons principalement pour travailler avec des bits. Lorsque est utilisé sur des valeurs booléennes, les valeurs booléennes sont converties en valeurs entières, c'est-à-dire 1 pour vrai et 0 pour faux.

Voyons un exemple de réinterprétation du cast:

#include using namespace std; int main() { int* ptr = new int(97); char* ch = reinterpret_cast(ptr); cout << ptr << endl; cout << ch << endl; cout << *ptr << endl; cout << *ch << endl; return 0; }

Production:

0x3ef3090
à
97
à

Dans l'exemple ci-dessus, nous avons déclaré un pointeur entier ptr pointant sur la valeur 97. Ensuite, nous déclarons un pointeur de caractère ch et le transtypons ptr en utilisant.

Ensuite, nous imprimons diverses valeurs. Le premier que nous imprimons est ptr qui pointe vers un emplacement entier. Par conséquent, il imprime une adresse.

La valeur suivante ch contient la valeur 97 et affiche donc «a» qui est l'équivalent ASCII de 97. La valeur suivante «* ptr» contient la valeur 97 tandis que «* ch» contient l'équivalent ASCII de 97, c'est-à-dire «a» tel qu'il est converti en utilisant le reinterpret_cast.

# 4) Const Cast

L'opérateur de conversion est utilisé pour modifier ou manipuler la constance du pointeur source. Par manipulation, nous entendons qu'il peut s'agir de définir constness sur un pointeur non const ou de supprimer constness d'un pointeur const.

La condition pour réussir à convertir l'opérateur est que le pointeur et la source qui est convertie doivent être du même type.

Prenons un exemple pour comprendre cela.

#include using namespace std; int printVal(int* ptr) { return(*ptr*10); } int main(void) { const int value = 10; const int *ptr = &value; int *ptr_cast = const_cast (ptr); cout <<'printVal returned = '<< printVal(ptr_cast); return 0; }

Dans cet exemple, nous voyons que la fonction «printVal» accepte un pointeur non const. Dans la fonction principale, nous avons une variable const «valeur» assignée au pointeur const ptr.

Afin de passer ce pointeur const à la fonction printVal, nous le castons en appliquant afin de supprimer la constness. Ensuite, nous passons le pointeur ptr_cast à la fonction pour obtenir les résultats souhaités.

Conclusion

Avec cela, nous allons conclure ce sujet de la conversion de type en C ++. Nous avons tout vu sur les conversions implicites et explicites utilisées en C ++.

Cependant, il faut être conscient que pour éviter la perte de données et d'autres difficultés de ce type, les conversions ou le typage ne doivent être appliqués à bon escient que si la situation nécessite l'utilisation.

=> Regardez le guide de formation C ++ pour débutants ici.

lecture recommandée

^