Vous n'êtes pas identifié.
Pages: 1 2
remplace aussi
char* (*tab)=NULL;
par
char **tab=NULL;
ça sera plus lisible
Hors ligne
euh sizeof renvoie uniquement la taille en octet du type de la variable... il me semble!
Hors ligne
oui c'est ca je crois
en tout cas c kom ca ke moi je m'en sert
Hors ligne
euh sizeof renvoie uniquement la taille en octet du type de la variable... il me semble!
pour un (vrai) tableau, ca renvoie la taille du tableau
Hors ligne
char * truc = "hello"; // sizeof(truc) renvoie 2 ( = taille d'un pointeur)
char truc [] = "hello"; // sizeof(truc renvoie 6 ( = 5 caracteres + 1 caractere de fin de chaine)
Hors ligne
ben c normal vu qure dans les 2 cas t'as juste un pointeur....
Hors ligne
non nykos, le premier est un vrai tableau, le second est un faux, c'est normal que ca donne 6 (la taille du tab) pour le vrai, et 2 (la taille du pointeur) pour le faux
mastermage, t'as du oublier de changer la valeur en copiant-collant
Hors ligne
Juste un autre ptit test...
Hors ligne
oui effectivement g fait copier coller, mais de toute facon ca m'aurait etonné que 2 = 5+1
Hors ligne
oui bon moi j'utilise sizeof que sur les types primaires donc ca me retourne la taille du type pas la taille d'un tableau
Hors ligne
pour le compilateur uniquement c'est différent, dans le code assembleur ils doivent être identiques, c'est à dire un unsigned int qui représente une adresse par rapport à DS qui pointe sur le premier caractère de la chaîne "hello".
Hors ligne
logique, d'ailleurs sizeof est presque une "macro" (avec des gros guillemets) dans le sens où ce n'est pas une instruction traduite en asm, elle est directement remplacée par un entier... la distinction entre les 2 types est nécessaire pour les premieres passes du compilo, mais apres elle disparait
Hors ligne
en tout cas c clairement différent de faire :
char* buf = "toto";
char buf2[] = "toto";
meme en asm il y aura une différence. Sauf le cas ou buf est déclarée en variable globale.
buf est pointeur dans la valeur contenu représente une adresse, ou pour buf2 la valeur c le premier élément du tableau, c un pointeur constant.
Donc dans l'asm inline du C, pour avoir l'offset fo écrire "__asm mov si, OFFSET buf2" contrairement à buf où un simple "__asm mov si, buf" suffit
Hors ligne
oui d'ailleur les pointeurs constants on ne peut pas les modifier (logique) et on ne peut d'ailleurs pas faire dans ce cas &buf2, le compilateur l'accepte quand même et &buf2==buf2.
Je me souviens m'être heurté à ce problème
Mais y'a t-il une différence dans le code machine générée? , buf2 est toujours une adresse pointant sur le premier caractère de "toto", non ?
J'ai fait un petit programme test:
#include <stdio.h> int main() { char test [] ="truc_1"; char *test2 ="truc_2"; printf("test="%s" test2="%s"nn", test, test2); printf(" test value: 0x%X, test2 value: 0x%Xnn", (unsigned int)test, (unsigned int)test2 ); printf(" test address: 0x%X, test2 address: 0x%Xnn", (unsigned int)&test, (unsigned int)&test2 ); printf(" test[1] address: 0x%X, test2[1] address: 0x%Xnn", (unsigned int)&test[1], (unsigned int)&test2[1]); printf("&test="%s" &test2="%s"nn", (char *)(&test), (char *)(&test2)); printf("DS=0x%0X", (unsigned int)_DS); return 0; }
voici ce qu'il retourne:
E:TCProgsavirer>test test="truc_1" test2="truc_2" test value: 0xFFEE, test2 value: 0x15E9 test address: 0xFFEE, test2 address: 0xFFEC test[1] address: 0xFFEF, test2[1] address: 0x15EA &test="truc_1" &test2="Ú§truc_1" DS=0x1550
Ce que je ne comprend pas c'est pourquoi la valeur de "test2" est si différente de la valeur de "test", alors que si on regarde avec un éditeur hexa, les 2 chaînes sont côte à côte dans l'exécutable.
Hors ligne
c koi la différence entre %X et %p
moi j'avais appris avec %p
Hors ligne
char test [] ="truc_1"; //test = adresse constante de le premiere lettre de "truc" char *test2 ="truc_2"; //test2 = variable de 2 octets, contenant l'adresse de la premiere lettre de "truc 2"
la difference c'est que dans le code asm (ou binaire peu importe) généré, la valeur de test va etre utilisée directement, alors que test2 est 1 variable. en asm ca va etre dans le style:
; x = test[0] mov al, [test] mov [x], al ;x = test2[0] mov bx, [test2] mov al, [bx] mov [x], al
Hors ligne
en écrivant char test [] ="truc_1";
le compilo fait une COPIE de la chaine de caractère "truc_1" dans test qui sera ensuite empiler, d'où l'écart d'adresse. Test pointe dans la pile et buf pointe sur une variable globale présente dans l'exe.
Remplace la première ligne par "static char test [] ="truc_1";" pour éviter la copie.
Hors ligne
Pages: 1 2