Considérez le code suivant:
#include <stdio.h>
int main(void)
{
int a[10];
printf("%d",(int)sizeof(a)); //prints 10*sizeof(int) (40 on my compiler)
printf("%d",(int)sizeof(a-3)); //prints sizeof(int) (4 on my compiler)
}
4 Réponses :
et note que (A-3) code> a type int * code> et il vous imprime Tailleof (int *) code> qui est sur votre plate-forme. p>
tailleOf () code> n'est plus une constante de temps de compilation en C99 (en raison des réparations de longueur variable). P>
Pour être clair - le résultat de Tailleof code> n'est pas une constante de temps de compilateur uniquement lorsque l'opérande est un tableau de longueur variable. Il est toujours une constante pour les autres types d'opérande.
NOPE, dans le second cas, l'argument est interprété comme un pointeur int * code> ayant également une taille égale à 4 sur votre machine. P>
Le Disons que vous avez un tableau donc, quand vous DO de ce qui précède, La "conversion" est due à l'opérateur de soustraction. Vous pouvez voir un résultat similaire et peut-être plus surprenant avec l'opérateur de la virgule: p> imprimera également Taille de l'opérateur code> n'évalue pas son argument, il uniquement regarde le type de son opérande. A code> avec type "Array [N] de type T". Ensuite, dans la plupart des cas, le type du nom A code> est "pointeur sur t" ( t * code>) et la valeur du pointeur est l'adresse du premier élément de la matrice ( & a [0] code>). C'est-à-dire que le nom d'un tableau "se désintègre" à un pointeur à son premier élément. Le "décomposition" ne se produit pas dans les cas suivants: p>
A code> est utilisé avec l'opérateur Adresse du ( & CODE>), LI>
A code> (il est illégal d'attribuer aux tableaux en C) et li>
a code> est l'opérande de la taille de code> opérateur. li>
ul> Taille de A code> vous donne N code> fois Tailleof (t) code>. p> TAILLEOF (A-3) CODE>, Type de l'opérande à TAILLEOF CODE> est déterminé par l'expression A-3 code>. Étant donné que A code> dans A-3 code> est utilisé dans un Contexte de la valeur (c.-à-d. Aucun des trois contextes ci-dessus), son type est" pointeur à int ", et le nom A code> décrit sur un pointeur sur A [0] code>. En tant que tel, calculer A-3 code> est un comportement non défini, mais étant donné que Tailleof code> n'évalue pas son argument, A-3 code> est utilisé uniquement pour déterminer Le type de l'opérande, le code est donc correct (voir le premier lien ci-dessus pour plus). p> Tailleof (A-3) code> est équivalent à Tailleof (int *) code>, qui est 4 sur votre ordinateur. p> Tailleof (int *) code>, à cause de L'opérateur de la virgule qui aboutit à a code> est utilisé dans un contexte de valeur. p> p>
Il ne doit pas non plus être imprimé avec Quoi qu'il en soit, tailleOf () code> renvoie la taille d'un type, de sorte que le type est ce qui est important. p>
% d code>. À tout le moins, le jetez explicitement à non signé long code> ou non signé long long code> et utilisez le spécificateur de format approprié. Lors de l'enseignement C, j'ai eu un étudiant obtenu la mauvaise réponse en impression Taille_t code> avec % d code> car le manuel dit à tort à tort. P>
A code> est un type de tableau. Dans C, les types de tableau sont décomposés aux types de pointeur si vous faites presque n'importe quoi avec eux ou éternuez fort, donc tout ce que vous faites pour A code> donnera un type de pointeur. Comme vous l'avez découvert, l'ajout ou la soustraction d'un numéro se décomposira. (Après tout, un tableau ne peut pas être utilisé en arithmétique, mais un pointeur peut.) P>
@David: Tant que le résultat ne déborde pas, si on jette l'expression comme (int) code>, puis l'imprimez avec "% d" code> est correct. Dans ce cas, il est presque certain que la taille correspondra à un int code>. En C99, on utiliserait "% zu" code> bien sûr. Pour C89, votre suggestion est meilleure que l'impression avec "% d" code> après la mise en moulage comme (int) code> car il est plus sujeux de débordement.
@Alok: True, mais le casting est beaucoup plus important que ce que vous lancez. En outre, je connais très bien le C89 et je n'ai pas utilisé C99, et cela montre probablement.
L'OP a la distribution dans sa question. Je suis d'accord avec vous - sans le casting, "% d" code> est faux, mais le document printf () de l'OP () code> est ok aussi longtemps qu'il n'y a pas de débordement.
Le second imprime en fait
tailleOf (int *) code>, pasTailleof (int) code>.Tailleof (int *) Code> Il se trouve que 4 aussi sur votre plate-forme.En outre, la manière appropriée d'imprimer une valeur
taille_t code> (la valeur renvoyée parTailleof code>) est avec"% zu" code>, en supposant que votre compilateur prend en charge fonctionnalité de C99 particulière. Sinon, un meilleur pari serait de le jeter à unnon signé code> ounon signé long code>.