Impression des éléments d'un tableau

Question

La sortie attendue du programme C suivant est d'imprimer les éléments du tableau. Mais quand il est réellement exécuté, il ne le fait pas.

#include<stdio.h> 

#define TOTAL_ELEMENTS (sizeof(array)/sizeof(array[0])) 

int array[] = {23,34,12,17,204,99,16}; 

int main() 
{ 
    int d; 

    for(d=-1;d <= (TOTAL_ELEMENTS-2);d++) 
     printf("%d\n",array[d+1]); 

    return 0; 
} 

Quelle est la raison?

Answer 1

Lorsque vous effectuez la comparaison d <= (TOTAL_ELEMENTS-2), une conversion de type est effectuée. d est de type signed int tandis que (TOTAL_ELEMENTS-2) est de type size_t, qui est un type non signé. Les règles de C indiquent que lorsqu'un opérateur a un argument signé et un argument non signé, et que l'argument non signé est de taille supérieure ou égale à l'argument signé, alors l'argument signé est converti en unsigned.

C'est, la comparaison se termine comme:

(size_t) d <= (TOTAL_ELEMENTS-2) 

Et parce que size_t est non signé, (size_t) -1 est un nombre vraiment, vraiment grand, pas -1 plus. Pour un size_t 32 bits, ce serait 2 - 1 = 4,294,967,295.

Pour résoudre ce problème, vous pouvez convertir explicitement le côté droit de signé int:

d <= (int) (TOTAL_ELEMENTS-2) 

Ou, mieux, simplement se débarrasser de l'indexation négative bizarre et tel.

Pour référence ultérieure, activez tous les avertissements du compilateur vous pouvez. gcc, par exemple, affichera un avertissement si vous activez -Wall -Wextra:

$ gcc -o arrayprint -Wall -Wextra -ansi arrayprint.c 
arrayprint.c: In function ‘main’: 
arrayprint.c:11: warning: comparison between signed and unsigned 

Answer 2

TOTAL_ELEMENTS est non signé. -1, lorsqu'il est converti en unsigned, est un nombre vraiment énorme, qui n'est pas inférieur à 6. Ainsi, votre boucle ne s'exécute jamais.

Answer 3

La raison est que la boucle n'est jamais exécutée. En effet, TOTAL_ELEMENTS renvoie un size_t, un type non signé.

Vous pouvez résoudre ce problème en lançant (TOTAL_ELEMENTS-2) dans un int.

Answer 4

Vous devez effectuer les opérations suivantes:

for(d=0;d < TOTAL_ELEMENTS;d++) 
    printf("%d\n",array[d]); 

comme sizeof(...) produit une valeur non signée.

Answer 5

Au début, je ne savais pas. Mais quand je compilé en utilisant GCC, il était évidemment apparente:

$ gcc -Wall -Wextra -Os a.c 
a.c: In function `main': 
a.c:11: warning: comparison between signed and unsigned 

Vous avez donc une comparaison comme suit:

(int) -1 <= (size_t) 5 

Comme l'un des types est signé et l'autre est non signé, ils ont d'abord besoin d'être converti en un type commun. Dans ce cas, il s'agit de size_t. Cela en fait:

(size_t) -1 <= (size_t) 5 

Maintenant -1 ne peut pas être représenté dans un type non signé.Par conséquent, 2^32 (ou cependant de bits size_t HAS) est ajouté, ce qui le rend 4294967295. donc la comparaison est vraiment:

4294967295 <= 5 

Et c'est false, donc le corps de la boucle est jamais exécutée.

Answer 6

changer simplement

#define TOTAL_ELEMENTS (sizeof(array)/sizeof(array[0])) 

Avec

#define TOTAL_ELEMENTS (int)(sizeof(array)/sizeof(array[0]))-2