C ++ entiers non signés

Le type de données entier en C ++ est divisé en de nombreux sous-types. L'un de ces sous-types est les entiers non signés. Les entiers non signés sont capables de stocker uniquement les nombres entiers positifs. Les entiers non signés en C ++ sont préférés lors de la manipulation des bits dans les systèmes d'exploitation, car vous avez un espace de stockage limité. De plus, ils peuvent également être utilisés pour l'indexation du tableau, car l'indice d'un tableau ne peut jamais être négatif. Cet article est consacré à la discussion des entiers non signés en C ++ dans Ubuntu 20.04.

La taille des entiers non signés en C ++:

La taille d'un entier non signé typique en C ++ est de 4 octets. Pour confirmer cela, vous pouvez jeter un œil à l'extrait de code suivant:

Dans cet extrait de code, nous venons d'utiliser l'instruction «cout» avec la fonction «Sizeof». Le paramètre que nous avons mis en œuvre sur cette fonction est «non signé». Cela signifie que cette déclaration renverra la taille d'un entier non signé en octets.

Après avoir exécuté cet extrait de code C ++, nous avons reçu la sortie indiquée dans l'image suivante, ce qui confirme que l'entier non signé en C ++ a la taille de 4 octets:

Comment déclarer un entier non signé en C++?

Les entiers non signés peuvent être déclarés très facilement en C++. Vous pouvez voir l'extrait de code suivant déclarer un entier non signé en C ++ dans Ubuntu 20.04:

Dans cet extrait de code, nous avons déclaré un entier non signé avec l'instruction «non signé int var» et lui attribué la valeur «255». Ensuite, nous avons utilisé l'instruction «cout» pour afficher la valeur de cet entier non signé sur le terminal.

Dans quels scénarios devons-nous éviter d'utiliser les entiers non signés en C++?

Il existe certaines situations dans lesquelles l'utilisation des entiers non signés devrait être strictement évitée en C ++ car ce faisant, cela peut entraîner des sorties très erronées. Ces erreurs ne peuvent pas être détectées simplement en regardant le code C ++. De plus, ils ne peuvent pas non plus être détectés au moment de la compilation. Au lieu de cela, vous ne pourrez attraper ces erreurs qu'une fois que vous aurez exécuté votre code C ++. Jetons un coup d'œil à certains de ces scénarios afin que vous puissiez éviter d'utiliser les entiers non signés en C ++ dans ces cas.

Scénario # 1: attribuant un nombre négatif à une variable entière non signée:

Les entiers non signés sont utilisés pour contenir uniquement les nombres entiers non négatifs. Cependant, le programmeur peut toujours attribuer un nombre négatif à une variable entière non signée. Ce nombre négatif est toujours enroulé au nombre le plus proche dans la plage. Ce concept est connu sous le nom d'emballage modulo. Aucune erreur n'est générée dans ce cas, mais la valeur que vous obtenez n'est certainement pas la bonne. Vous pouvez consulter l'extrait de code suivant pour comprendre ceci:

Dans cet extrait de code, nous avons attribué la valeur «-1» à une variable entière non signée. Ensuite, pour vérifier si la valeur correcte est imprimée sur le terminal ou non, nous avons utilisé l'instruction «cout» avec la variable «var».

Lors de l'exécution de ce code, nous avons appris que la valeur de la variable entière non signée est devenue «4294967295» au lieu de «-1», comme indiqué dans l'image ci-dessous:

Scénario n ° 2: effectuer une soustraction de deux entiers non signés dans lesquels le nombre à soustraiter est plus grand que le nombre à soustraire de:

Chaque fois que nous effectuons une soustraction de deux entiers dans une situation où le premier nombre est plus petit que le second, alors nous recevons toujours une sortie négative. Par conséquent, dans cette situation, nous ne devons jamais utiliser les entiers non signés. L'extrait de code suivant le démontre:

Dans cet extrait de code, nous avons deux entiers non signés, «var1» et «var2», dont les valeurs sont «2» et «7», respectivement. Nous voulions soustraire «2» de «7». Le résultat de cette soustraction est «-5». Cependant, vous devrez exécuter cet extrait de code pour déterminer comment cette soustraction fonctionne avec des entiers non signés.

L'exécution de cet extrait de code a produit le résultat illustré dans l'image suivante. Encore une fois, bien que nous n'ayons reçu aucun message d'erreur, notre sortie s'est toujours avérée incorrecte.

Scénario # 3: Utilisation des entiers non signés avec des instructions conditionnelles:

Il y a certaines conditions qui s'exécutent lorsqu'une variable est inférieure à une autre. Cependant, si nous comparons les nombres négatifs et positifs tout en utilisant les entiers non signés, le résultat pourrait être inattendu. Pour développer cela, nous avons conçu l'extrait de code suivant:

Dans cet extrait de code, nous avons deux variables entières non signées, «var1» et «var2» dont les valeurs sont respectivement «-1» et «1». Ensuite, nous avons une instruction «IF» qui sera exécutée si «var1

Pour assister à cela, vous pouvez voir la sortie indiquée dans l'image suivante. Cette sortie indique que «var1» n'est pas inférieure à «var2», qui est logiquement et mathématiquement incorrect:

Scénario # 4: Fonctions d'appel avec entiers non signés:

Parfois, vous définissez de telles fonctions qui acceptent les entiers non signés comme paramètres. Encore une fois, si quelqu'un transmet une valeur négative à cette fonction, elle sera toujours appelée mais produira de mauvais résultats. Pour représenter cela, nous avons implémenté l'extrait de code suivant:

Dans cet extrait de code, nous avons une fonction nommée «DisplayNumber», qui accepte un entier non signé «num». Dans cette fonction, nous voulons simplement imprimer la valeur de ce nombre sur le terminal. Dans notre fonction «Main ()», nous avons appelé cette fonction avec le numéro «-1».

Vous pouvez voir la sortie de cet extrait de code dans l'image illustrée ci-dessous. Selon cette sortie, la valeur du nombre est «4294967295» au lieu de «-1»:

Scénario # 5: Utilisation des entiers non signés comme compteurs de boucle:

Dans le dernier scénario, nous utiliserons l'intégralité non signée comme compteur de boucle en C++. Vous pouvez le voir à partir de l'extrait de code suivant:

Dans cet extrait de code, nous avons défini une simple boucle «pour» dont l'itérateur est un entier non signé, et nous avons décrémenté cet entier non signé dans chaque itération. Nous sommes restés coincés dans une boucle infinie lorsque nous avons exécuté ce code, comme vous pouvez le voir sur la sortie ci-dessous. Cela s'est produit uniquement parce que dans la dernière itération lorsque la valeur de l'itérateur a été décrémentée à «-1», au lieu de briser la boucle, cet itérateur a été enroulé avec l'entier non signé le plus proche dont la valeur était supérieure à «5». Cela continuait à se produire dans chaque itération, c'est pourquoi nous avons ce type de sortie.

Conclusion:

Dans cet article, nous voulions parler des différents aspects de l'utilisation des entiers non signés en C ++ dans Ubuntu 20.04. Tout d'abord, nous avons partagé la taille des entiers non signés en C ++ avec vous, suivis de leur déclaration. Après cela, nous avons expliqué que les différents scénarios dans lesquels l'utilisation des entiers non signés devraient être strictement évités en mettant en évidence les problèmes qu'ils peuvent causer. Par conséquent, après avoir parcouru cet article, vous différencierez facilement les situations dans lesquelles les entiers non signés devraient et ne devraient pas être utilisés. Nous espérons que vous avez trouvé cet article utile et veuillez consulter l'indice de Linux pour des articles plus informatifs.