Trop d'éléments dans un tableau!

Question

Désolé si cela est une question noob :(.

morceau de code C.

int array[5];
int cnt;

for(cnt = 0; cnt <= 10; cnt+=1)
{
      array[cnt] = cnt;
}

devrait donner une erreur, non? Non! Fonctionne très bien! Mais pourquoi est-ce? Il semble que -dans le premier ligne- un réseau de plus du double la taille (11) est définie. Vous pouvez même accéder à tableau [5 à 10] plus tard. Et qui me prêter à confusion. Il cesse de fonctionner lorsque vous définissez tableau [4 ou moins] ...

Merci d'avance.

Answer 1

Il peut arriver à travailler avec votre compilateur particulier et l'ordinateur, mais vous ne devriez pas compter là-dessus.

Le comportement de votre code selon la spécification du langage C est non défini . Cela signifie qu'il pourrait faire ce que vous espérez, ou il pourrait causer panne de votre ordinateur, ou il pourrait provoquer démons pour voler votre nez.

Contrairement aux langues de niveau supérieur tels que Java et C #, C vous fait confiance et ne réalise pas des contrôles explicites sur les limites des tableaux. Vous êtes censé être responsable et non marcher en dehors des limites du tableau.

Answer 2

Cela ne « fonctionne » si votre définition des « œuvres » est synonyme de « n'a pas encore écrasé ».

Answer 3

Ce que vous voyez est comportement non défini , causé par vous accéder au tableau avec un index non valide. un comportement non défini signifie que tout peut arriver, y compris votre programme semblant fonctionner correctement.

Answer 4

"Mais pourquoi est-ce?"

Parce que c'est la façon dont C est.

Array limites ne sont pas vérifiées au moment de l'exécution.

C'est la "Loi du C"

Answer 5

Je viens tiens à souligner que tout cela est bien défini. Votre exemple « fonctionne » dans cet exemple spécifique, car les deux variables se trouvent sur la pile. C'est l'adresse de cnt est juste au-dessous de la fin du tableau. Lorsque cnt atteint cnt == 5 le tableau de déclaration [cnt] = cnt; ne pas écrire dans la mémoire dédiée au tableau, mais juste après, où se trouvait l'adresse de cnt. Il est tout simplement la chance que cela ne modifie pas votre compteur. Lorsque cnt> 5 il n'y a pas de mémoire à la corbeille et il suffit d'écrire dans le « vide de la pile » (ne sais pas le mot approprié).

un autre exemple pour illustrer ceci:

int main(int ac,char **av)
{
    int a[5];
    int cnt;
    int cnt2=3;

    for(cnt=0;cnt<7;cnt++) {
        a[cnt]=cnt;
        printf("%d %d %d\n", a[cnt], cnt, cnt2);
    }
}

sortie:

0 0 3
1 1 3
2 2 3
3 3 3
4 4 3
5 5 5
6 6 5

Les deux dernières écritures de la boucle écrase les données de la pile après une [] et peuvent donner des erreurs très confuses. Dans ce cas, le cnt2 est saccagé.

Answer 6

Les tableaux en C ne sont pas vérifiées lors de l'exécution. En d'autres termes, vous pouvez « définir » un tableau de taille N et accéder heureusement hors de la fin du tableau lié. Si vous allez à l'extrémité du tableau, alors vous bousillerez mémoire quelque part sur la pile (ou le tas).

Une fois que vous détritus la mémoire quelque part, votre programme est susceptible de tomber en panne. Ces accidents peuvent être difficiles à traquer, car ils pourraient tomber en panne loin de l'endroit où vous envahirent en fait la fin du tableau.

En général, lorsque vous déclarez des tableaux en C, il est préférable d'utiliser une sorte de constante ou #define pour marquer la taille du tableau:

#define MAX_ELEMENTS 10
int array[MAX_ELEMENTS];
int cnt;
for(cnt = 0; cnt < MAX_ELEMENTS; cnt+=1) {
   array[cnt] = cnt;
}

Si vous passez MAX_ELEMENTS dans l'attribution de tableau, vous risquez de remplacer la valeur de cnt. Vous pouvez remplacer une autre variable. Tout dépend du compilateur et la structure du code. A noter également l'utilisation du signe

Answer 7

limites de tableau en C sont pas nécessairement vérifié lors de l'exécution. La norme laisse implementors libre de le faire si elles le souhaitent, ou non - qui fait partie de ce qui est non défini . Sur une mise en œuvre avec des pointeurs de graisse l'échantillon pourrait en effet provoquer une sorte d'erreur.

Answer 8

Une fois que vous avez l'extrémité du tableau, vous écrasez mémoire que le logiciel ne s'y attend pas et corrompre le tas. Vous le logiciel peut continuer à fonctionner, mais il sera très instable!

Answer 9

Cela dépend de la manière dont la mémoire de pile est emballée. En outre, il se fera un plaisir d'écraser ces valeurs et même les lire, mais la plupart vous êtes probablement corrompre la pile.