Reprise du message précédent :

>> oui mais encore, précise
 

Faute avouée à moitié pardonée

déjà qu'un tableau et un pointeur sont 2 choses fondamentalements différentes ...

regarde les caractéristiques de l'un et l'autre (la manière d'allouer de l'espace pour tes données par exemple, puis va lire la doc au sujet de ce que tu auras trouvé), tu vas entrevoir des différences non?

j'ai pas encore tout lus mais,
 
un pointeur ca contient une adresse.
 
quand on déclare un tableau on créer un pointeur qui pointera vers la premier élément de ce tableau.
 
et quand je fais un malloc et que j'alloue de la mémoire à un pointeur j'ai tjrs penssé que ca revenait à faire un tableau, le pointeur pointera vers l'adresse de cette zone mémoire créer avec malloc.
 
je vais continuer à lire j'ai surement dis des bétises.

manqué

qu'est-ce que tu appelles une l-value Taz ?

une valeur-gauche

une valeur qu'on ne peut affecter.  
 

 
je vais faire un 2ème lancé alors,
 
quand on déclare un tableau char t[5]; ya un espace de la taille de 5 caractères qui est alloué et t est transformer en un pointeur qui contient &t[0];
 
maintenant dans le cas du tableau de pointeur, char * p[5]; allocation de mémoire de la taille de 5 pointeurs et p devient un pointeur de pointeur ! qui contient l'adresse de &p[0]
 
maintenant avec malloc que se passe t'il exactement quand j'alloue de la mémoire ca je sais pas encore.

à gauche d'un = donc

y a aucune transformation du tout. t est un tableau et comme dit chaque T[N] est un type distinct. t est castable implicitement en T* de manière que t -> &t[0]

p est un tableau pas un pointeur

malloc te renvoie un pointeur sur le premier byte d'une zone mémoire contigüe non-initialisée de taille n

quand vous parlez de contigû en mémoire c que les adresses mémoires de chaques éléments se suivent ?

non, on veut dire <la définition du dictionnaire>

maintenant que j'ai saisi la différence entre tableau - pointeur,
 
j'en reviens à mon histoire de strcmp, mais ca m'explique pas le pourquoi du comment.
 
quand j'utilise dans mon strcmp,  *(char **)a  pour le tri d'un char *p[], c'est que qsort lui transmet donc un pointeur de pointeur de char alors que je n'ai qu'un tableau de pointeur de char.
 
j'y arriverai un jour  

le plus important, que se passe-t-il quand tu fais  
 
int m[1000][1000] ;
 
ou
 
int *m[1000] = malloc(1000*sizeof(int)) ;
 
c'est TRES différent au niveau de la mémoire...

int m[1000][1000];  
 
c'est un tableau m de 1000 éléments qui sont des tableaux de 1000 éléments qui sont des char.
 
niveau mémoire je ne sais pas trop mais je viens de faire un essais, si je fais un printf("%x",m[1]); par ex j'ai bien une adresse mémoire.
 
 
pour int *m[1000] = malloc(1000*sizeof(int)) ;
 
je comprend pas très bien l'écriture je ne savais pas qu'on pouvait alloué de la mémoire à un tableau de *, j'aurais fait une boucle pour allouer de la mémoire à chaque pointeur.

tu comprends surtout pas en fait comment on se sert de malloc
tu aurais ? ben fait donc, on a jamais dit le contraire

 
bein si comme tu me l'a dis toi même malloc(n) alloue un espace mémoire de taille n et renvois un pointeur qui pointe vers le début de cette zone.

je t'ai aussi donné la définition d'un tableau. alors fais pas l'idiot

 
je fais pas l'idiot    
 
je comprend tjrs pas le coup du *(char **)a dans mon strcmp c tout.

parce que a est en fait un char**

je sais mais pq c'est un char** dans le cas du p * [] et un char* dans le cas du p[][] c'est ca que je ne comprend pas.

ben parceque qsort appelle compare(&element[i], &element[j])

je crois qu'on est près du but la    
 
un peu plus haut je disais avoir fait un printf("%x",n[1]); (n[10][10] et avoir vu une adresse mémoire.
 
je suppose que cette adresse pointe sur le premier caractère du deuxième "sous tableau" donc que c un pointeur de caractère.
 
donc si qsort transmet &n[1] par exemple il envois donc l'adresse du pointeur de caractère qui pointe le premier caractère de la chaine à comparer.
 
maintenant avec le p * [], si il transmet &p[1],il transmet l'adresse d'un pointeur de car. qui pointe vers le premier caractère d'une chaine à comparer.
 
et ya de nouveau pas de différence entre les 2 dans mon résonnement donc...    

up    je voudrais vraiment comprendre.

quoi ? on a compris que tu comprenais pas, on y peut rien

dis moi se qui ne va pas dans mon résonnement au-dessus alors.

up pour que quelqun ai la gentillesse de me dire se qui ne va pas dans mon dernier résonnement,
 
merci...

 
moi je vais te poser une question par rapport à tes printfs:
 
qu'est-ce qui n'a pas d'adresse ?

je suis pas sur de comprendre ta question    
 
toute donnée à une adresse, se que je comprend pas c'est que dans le cas d'un tris de p[][] qsort transmet 2 pointeurs de char et dans le cas d'un tris de p * [] il transmet 2 pointeur de pointeur de char.
 
je dois rater un épisode quelque part mais où  

qsort appelle la fonction de comparaison avec deux pointeurs sur les éléments à comparer, c'est à toi d'interpréter les pointeurs dans ta fonction de comparaison...
 

ton char p[][], ramené au niveau p[] c'est quoi comme l'élément manipulé par qsort ?
 
et avec char *p[], c'est quoi l'élement manipulé ?

bein oui, je met cette exemple la comme fonction de comparaison
 

 
c'est dans le cas d'un tris d'un tableau de pointeur.
 
et dans le cas d'un tris d'un tableau t[][] mon strcmp devient
 

 
je comprend pas pq dans un cas c un *char que qsort envois à comparer et dans l'autre un **char.

bein p[][] ramené à p[] pour moi c un pointeur de char vu qu'un printf("%x",p[0]) me renvois une adresse qui pointe sur un char.
 
et dans le cas de p * [] , p[] c la même chose un pointeur de char c'est ca que je comprend pas.

pour p[][] rammené à p[] je suppose que ce n'est pas un *char et c'est la que je me trompe mais je vois pas bien pq ?

printf("%x",p[0]) te renverra toujours qqchose puisque comme tu l'as dit toute donnée a une adresse (hormis les registre du cpu pour répondre à ma question). donc printf soit il te prends l'adresse, soit il te sort un truc issu d'un cast. (dans le cas de ton exemple, printf ne prouves pas grand chose).
 

y'a personne pour aider ?

 
bon, pour trier un p[100][16], tu fais comment avec qsort au niveau de l'appel ?
et pareil avec un char *p[100].
 
entre un p[100][16] et un char *p[100], c'est quoi qui sera interverti par qsort en fonction du résultat de la comparaison ? (pour simplifier et sans entrer dans les détails de l'implémentation d'un quicksort)

bon.. lol
 
 
pour le printf("%x" ); si je fais ca sur un int je n'optient pas une adresse, j'obtient ca uniquement sur un pointeur, logique vu qu'un pointeur contient une adresse lol. c'est pour ca que je trouve pas ca très logique que x de p[x][] contienne une adresse et je parle pas de la sienne hein..  
 
pour qsort dans le cas d'un p * [] bein il intervertit les pointeur , et ca ca me pose pas de problème au niveau de la fonction de comparaison.
 
c'est pour le tableau p[][] que ca pose problème, il intervertit quoi ? bonne question lol si jme base sur mon résonnement d'au dessus il intervertit aussi des pointeurs de char c'est ca qui est fous