Pourquoi vois-je des valeurs étranges lorsque j’imprime des variables non initialisées?

Dans le code suivant, la variable n’a pas de valeur initiale et l’a imprimée.

int var; cout << var << endl; 

sortie: 2514932

 double var; cout << var << endl; 

sortie: 1.23769e-307

Je ne comprends pas ces chiffres de sortie. Quelqu’un peut-il m’expliquer cela?

En termes simples, var n’est pas initialisé et la lecture d’une variable non initialisée conduit à un comportement indéfini .

Alors ne le fais pas. Au moment où vous le faites, votre programme n’est plus assuré de faire ce que vous dites.


Formellement, “lire” une valeur signifie effectuer une conversion de valeur d’une valeur à l’autre. Et le § 4.1 indique “… si l’object n’est pas initialisé, un programme nécessitant cette conversion a un comportement indéfini”.

En termes pragmatiques, cela signifie simplement que la valeur est fouillée (après tout, il est facile de voir lire un int , par exemple, obtient simplement des bits aléatoires), mais nous ne pouvons en conclure cela, sinon vous définiriez un comportement non défini.

Pour un exemple réel, considérons:

 #include  const char* test() { bool b; // uninitialized switch (b) // undefined behavior! { case false: return "false"; // garbage was zero (zero is false) case true: return "true"; // garbage was non-zero (non-zero is true) default: return "impossible"; // options are exhausted, this must be impossible... } } int main() { std::cout << test() << std::endl; } 

Naïvement, on pourrait conclure (via le raisonnement dans les commentaires) que cela ne devrait jamais être imprimé "impossible" ; mais avec un comportement indéfini, tout est possible. Comstackz-le avec g++ -02 .

Quand tu fais:

int var;

Vous déclarez seulement un entier nommé var . Vous ne l’initialisez pas avec une valeur, donc, quel que soit l’emplacement var , ce seront des données parasites.

int var = 5;

Déclarerait var et l’initialiserait à 5.

Voir plus: http://en.wikipedia.org/wiki/Uninitialized_variable

Vous obtenez toutes les données qui se trouvent sur la stack à la place que le compilateur a décidé que la variable devrait être interprétée comme un entier ou un double. Ce sera probablement la même chose à chaque fois que votre programme s’exécutera, car les programmes se comportent généralement de manière déterministe. Bien qu’il existe également de nombreux cas dans lesquels le programme ne sera pas identique. Si vous modifiez le moins du monde votre programme ou le faites prendre des décisions en fonction de la saisie de l’utilisateur avant que vous obteniez ce code, vous pouvez obtenir ou non des numéros différents.

Fondamentalement, la valeur d’une variable que vous n’avez pas initialisée est non spécifiée et peut être absolument n’importe quoi. Il n’y a pas de rime ou de raison à ce qu’il y a.

Faire cela est généralement une mauvaise pratique. Vous voulez des programmes qui se comportent de manière prévisible, et le fait d’avoir des variables non initialisées est une source d’imprévisibilité. Notez que ce n’est surtout pas une source d’aléatoire, mais simplement une imprévisibilité. La plupart des compilateurs vont se plaindre de ce genre de code si vous activez tous les avertissements.

En C ++, lorsque vous déclarez une variable, le compilateur lui atsortingbue une adresse de mémoire. Et c’est tout, aucun nettoyage n’est effectué. Ceci est principalement dû au fait que C ++ (et C) a été construit avec la performance à l’esprit. C ++ ne perd pas de temps à initialiser une adresse, à moins que vous ne lui indiquiez explicitement de le faire.

Et la prétendue ordure que vous voyez est ce qu’elle a été laissée à cette adresse par la dernière variable qui l’a utilisée.

D’autres langues initialiseront les données pour vous. En fait, C # ne vous laissera pas utiliser la variable tant que vous ne l’initialisez pas. Ces langages sont conçus pour être sûrs , dans le sens où ils ne vous permettent pas d’écrire un code qui utilise par erreur une adresse non initialisée et de planter votre programme ou, pire, de corrompre vos données.

vous n’avez pas initialisé var dans les deux cas, vous obtenez donc une sortie de déchets.

avais tu fait

const int var(5);

il serait initialisé avec la valeur 5

Lorsque vous déclarez var, un emplacement en mémoire lui est atsortingbué. Cependant, cette mémoire n’est pas configurée par défaut, vous récupérez donc tout ce qui se trouvait auparavant. Ce sera une valeur de déchets qui n’a aucune signification.

En C ++, cela est vrai pour les variables membres et les variables locales. Cependant, dans des langages tels que Java et C #, vos variables membres sont automatiquement initialisées à 0 pour les types numériques, false pour les booléens et null pour les références. Cela n’est pas fait pour les variables locales et (au moins dans le compilateur C #), votre construction échouera si vous essayez de prendre la valeur d’une variable non initialisée.