Qu'advient-il déclaré, variable non initialisée en C? A-t-elle une valeur?

0 si globales ou statiques, pour une durée indéterminée si la classe de stockage est automatique

C a toujours été très précis sur les valeurs initiales des objets. Si global ou static, ils seront remis à zéro. Si auto, la valeur est indéterminée.

Ce fut le cas lors de la pré-C89 compilateurs et a été précisé par le K&R et dans DMR original C rapport.

Ce fut le cas en C89, voir la section 6.5.7 Initialisation.

Si un objet qui a automatique
durée de stockage n'est pas initialisé
explicitement, sa valeur est
durée indéterminée. Si un objet qui a
statique de la durée de stockage n'est pas
initialisé explicitement, il est
initialisé implicitement comme si chaque
membre qui a arithmétique type ont été
attribué 0 et chaque membre qui a
type de pointeur été attribué une valeur null
pointeur constant.

Ce fut le cas en C99, voir la section 6.7.8 Initialisation.

Si un objet qui a automatique
durée de stockage n'est pas initialisé
explicitement, sa valeur est
durée indéterminée. Si un objet qui a
statique de la durée de stockage n'est pas
initialisé explicitement, alors:
— si c'
a de type pointeur, il est initialisé à
un pointeur null;
— si elle a de l'arithmétique
le type, il est initialisé à (positif
ou non signé) zéro;
— si c'est un
globale, chaque membre est initialisé
(de manière récursive) conformément à ces
règles;
— si c'est une union, la première
nommé membre est initialisé
(de manière récursive) conformément à ces
des règles.

Sur ce qu'est exactement indéterminée moyens, je ne suis pas sûr pour C89, C99 dit:

3.17.2
une valeur indéterminée
soit une valeur indéterminée ou un piège
représentation

Mais indépendamment de ce que les normes de dire, dans la vraie vie, chaque page de pile en fait de commencer à zéro, mais quand votre programme ressemble à tout auto de stockage de valeurs de classe, il voit tout ce qui a été laissé par votre propre programme à la dernière fois qu'elle a utilisé ces pile d'adresses. Si vous allouer beaucoup de auto tableaux, vous verrez par la suite commencer soigneusement avec des zéros.

Vous pourriez vous demander, pourquoi est-il de cette façon? Une autre SORTE de réponse traite de cette question, voir: https://stackoverflow.com/a/2091505/140740

Ubuntu 15.10, Noyau 4.2.0, x86-64, GCC 5.2.1 exemple

Assez de normes, regardons une mise en œuvre 🙂

Variable locale

Normes: un comportement indéfini.

Mise en œuvre: le programme alloue de l'espace de pile, et ne se déplace jamais rien à cette adresse, donc tout ce qui était là précédemment est utilisé.

#include <stdio.h>
int main() {
    int i;
    printf("%d\n", i);
}

compiler avec:

gcc -O0 -std=c99 a.c

sorties:

0

et la décompilation avec:

objdump -dr a.out

à:

0000000000400536 <main>:
  400536:       55                      push   %rbp
  400537:       48 89 e5                mov    %rsp,%rbp
  40053a:       48 83 ec 10             sub    $0x10,%rsp
  40053e:       8b 45 fc                mov    -0x4(%rbp),%eax
  400541:       89 c6                   mov    %eax,%esi
  400543:       bf e4 05 40 00          mov    $0x4005e4,%edi
  400548:       b8 00 00 00 00          mov    $0x0,%eax
  40054d:       e8 be fe ff ff          callq  400410 <printf@plt>
  400552:       b8 00 00 00 00          mov    $0x0,%eax
  400557:       c9                      leaveq
  400558:       c3                      retq

De notre connaissance de x86-64 conventions d'appel:

• %rdi est le premier argument de printf, donc la chaîne "%d\n" à l'adresse 0x4005e4

• %rsi est le deuxième argument de printf, ainsi i.

  Il vient de -0x4(%rbp), qui est le premier de 4 octets variable locale.

  À ce point, rbp est dans la première page de la pile a été alloué par le noyau, afin de comprendre que la valeur de nous regarder dans le code du noyau et de trouver ce qui définit.

  TODO ne le noyau jeu de mémoire à quelque chose avant de le réutiliser pour d'autres processus, lorsqu'un processus meurt? Si non, le nouveau processus serait capable de lire la mémoire des autres programmes, les fuites de données. Voir: Sont les valeurs non initialisées jamais un risque pour la sécurité?

Ensuite, nous pouvons aussi jouer avec notre propre pile de modifications et d'écrire des choses amusantes comme:

#include <assert.h>

int f() {
    int i = 13;
    return i;
}

int g() {
    int i;
    return i;
}

int main() {
    f();
    assert(g() == 13);
}

Variables globales

Normes: 0

Mise en œuvre: .bss section.

#include <stdio.h>
int i;
int main() {
    printf("%d\n", i);
}

gcc -00 -std=c99 a.c

compile:

0000000000400536 <main>:
  400536:       55                      push   %rbp
  400537:       48 89 e5                mov    %rsp,%rbp
  40053a:       8b 05 04 0b 20 00       mov    0x200b04(%rip),%eax        # 601044 <i>
  400540:       89 c6                   mov    %eax,%esi
  400542:       bf e4 05 40 00          mov    $0x4005e4,%edi
  400547:       b8 00 00 00 00          mov    $0x0,%eax
  40054c:       e8 bf fe ff ff          callq  400410 <printf@plt>
  400551:       b8 00 00 00 00          mov    $0x0,%eax
  400556:       5d                      pop    %rbp
  400557:       c3                      retq
  400558:       0f 1f 84 00 00 00 00    nopl   0x0(%rax,%rax,1)
  40055f:       00

# 601044 <i> dit que i est à l'adresse 0x601044 et:

readelf -SW a.out

contient:

[25] .bss              NOBITS          0000000000601040 001040 000008 00  WA  0   0  4

qui dit 0x601044 est droit dans le milieu de la .bss, qui commence à 0x601040 et est long de 8 octets.

La ELFE de la norme garantit ensuite que la section nommée .bss est complètement rempli avec des zéros:

.bss Cette section présente des données non initialisées qui contribuent à la
programme de la mémoire d'image. Par définition, le système s'initialise le
de données avec des zéros lorsque le programme commence à courir. La section occu-
les tartes à la n de l'espace fichier, comme indiqué par le type de section, SHT_NOBITS.

En outre, le type SHT_NOBITS est efficace et n'occupe pas d'espace sur le fichier exécutable:

sh_size Ce membre donne la taille en octets. À moins que la sec-
tion est de type SHT_NOBITS , la section occupe sh_size
octets dans le fichier. Une section de type SHT_NOBITS peut avoir une valeur non nulle
la taille, mais ça occupe pas d'espace dans le fichier.

C'est ensuite le noyau Linux à zéro que la région de mémoire lors du chargement du programme en mémoire quand il se met en marche.

La base réponse est, oui, il n'est pas défini.

Si vous voyez le comportement étrange de ce fait, il peut dépendait de l'endroit où elle est déclarée. Si au sein d'une fonction sur la pile, puis le contenu sera plus que probablement être différent à chaque fois que la fonction est appelée. Si c'est un statique ou d'un module de portée, il n'est pas défini, mais ne changera pas.

Parce que les ordinateurs ont finis à la capacité de stockage automatique des variables généralement lieu dans les éléments de stockage (si registres ou de la RAM) qui ont déjà été utilisés pour certains autres arbitraire but. Si une telle variable est utilisée avant une valeur a été attribuée à lui, que le stockage peut tenir quoi qu'il détenait précédemment, et donc le contenu de la variable sera imprévisible.

Comme un supplément de ride, de nombreux compilateurs peuvent garder de variables dans des registres qui sont plus grandes que les associés des types. Bien qu'un compilateur serait nécessaire pour s'assurer que toute la valeur de ce qui est écrit dans une variable et relire sera tronqué et/ou de signe étendu à sa bonne taille, beaucoup de compilateurs effectuer de telles troncature lorsque les variables sont écrites et s'attendre à ce que il aura été effectuée avant que la variable est en lecture. Sur ces compilateurs, quelque chose comme:

uint16_t hey(uint32_t x, uint32_t mode)
{ uint16_t q; 
  if (mode==1) q=2; 
  if (mode==3) q=4; 
  return q; }

 uint32_t wow(uint32_t mode) {
   return hey(1234567, mode);
 }

pourrait très bien entraîner wow() stocker les valeurs 1234567 dans les registres
0 et 1, respectivement, et en appelant foo(). Depuis x n'est pas nécessaire dans
"toto", et étant donné que les fonctions sont censé mettre à leur valeur de retour dans
inscrire 0, le compilateur peut allouer inscrire 0 à q. Si mode est 1 ou
3, inscrire 0 sera chargé avec 2 ou 4, respectivement, mais si c'est une
autre valeur, la fonction peut renvoyer tout ce qui était dans le registre 0 (c'est à dire la
valeur 1234567), même si cette valeur n'est pas dans la gamme de uint16_t.

D'éviter d'exiger des compilateurs de faire du travail supplémentaire pour s'assurer que non initialisée
les variables ne semblent jamais à contenir des valeurs en dehors de leur domaine, et éviter d'avoir besoin d'
pour spécifier une période indéterminée comportements dans trop de détails, que dit la Norme
que l'utilisation de non initialisée automatique des variables est un Comportement Indéfini. Dans
certains cas, les conséquences peuvent être encore plus surprenant qu'une
valeur en dehors de la plage de son type. Par exemple, étant donné:

void moo(int mode)
{
  if (mode < 5)
    launch_nukes();
  hey(0, mode);      
}

un compilateur pourrait en déduire que, parce que l'invocation moo() avec un mode qui est
plus de 3 conduira inévitablement à la programme en invoquant Undefined
Le comportement, le compilateur peut omettre le code qui ne serait pertinent
si mode est 4 ou plus, tels que le code qui empêcherait normalement
le lancement de bombes nucléaires dans de tels cas. Notez que ni la Norme, ni
moderne compilateur philosophie, serait de soins sur le fait que la valeur de retour
de "hey" est ignoré--l'acte d'essayer de le retourner donne un compilateur
licence illimitée pour générer du code arbitraire.

Aussi loin que je l'avais quitté, il est la plupart du temps dépend du compilateur, mais en général la plupart des cas, la valeur est pré suppose que 0 par le cas de déviation.

J'ai eu la valeur d'ordures en cas de VC++ alors que TC a donné de la valeur à 0.
- Je l'Imprimer comme ci-dessous

int i;
printf('%d',i);