J'aimerais comprendre ....

Bonjour,

ayant besoin de recuperer les lecteurs "actifs" sous windows, j'ai récupéré ce code sur le net.
Il fonctionne.

Cependant je souhaiterais aussi le comprendre (afin de re-utiliser ou modifier).

J'ai mis les commentaires qui me semblais juste mais je ne comprends pas vraiment la globalité. Comment fonctionne cette boucle ?

Si quelqu'un peut eclairer un peu ma lanterne...j'en serais ravi.

Merci

Code:

---

1 2 3 4 5 6 7

char szBuffer[1024]; //initialisation de la taille du buffer (Nb de caracteres = 2 octets par caracteres) GetLogicalDriveStrings(1024, szBuffer); //appel de l'API windows (taille du Buffer,variable recevant les données) char *pch = szBuffer; //definition du pointeur pour acceder aux éléments du tableau while (*pch) { //tant que....??? printf("%s\n", pch); //affiche la valeur de PCH convertion type char (chaine) pch = &pch[strlen(pch) + 1]; //nouvelle valeur PCH (prend la valeur du contnu du pointeur PCH ) = longueur de chaine PCH+1 a chaque boucle }

---

[Je pense ne pas me tromper, mais s'il y a des membres plus expérimentés qui veulent me rectifier, qu'ils n'hésitent pas :D ]

Voici une explication ligne par ligne :

char szBuffer[1024];
Ceci est suffisamment explicite, je pense ...

GetLogicalDriveStrings(1024, szBuffer);
Cette fonction, d'après ce que j'ai compris, stocke les lettres des lecteurs (je suppose C:, D: etc...) dans le tableau de caractères fourni. Elle ajoute un caractère nul (\0) à la fin de chaque lecteur. Ceci est essentiel pour la suite.

char *pch = szBuffer;
C'est une transformation de tableau en pointeur - exemple typique. Le pointeur est donc dirigé sur le premier caractère du tableau, et surtout on ne connaît plus la taille de ce dernier ! Ce qui va permettre au travers des manipulations qui suivent, de tromper les fonctions printf et strlen ...

while (*pch) {
Le début de la boucle. Tant que pch pointe sur un emplacement valide, c'est-à-dire que le caractère pointé n'est pas nul -> explications plus tard.

printf("%s\n", pch);
Ici, on affiche une chaîne de caractères. Une chaîne étant définie comme terminée par un caractère nul, la fonction est trompée par le caractère nul d'espacement qu'insère GetLogicalDriveStrings entre la lettre de chacun des lecteurs. Ceci permettant de pouvoir enregistrer tous les lecteurs sans avoir besoin d'un tableau à 2 dimensions, peu pratique à manipuler en utilisant tableaux et pointeurs C.

pch = &pch[strlen(pch) + 1];
C'est la ligne clé de la boucle. On déplace le pointeur pch, le but de la manipulation étant qu'il pointe sur le lecteur suivant.
Pour effectuer ceci, on dispose de deux informations à exploiter :
1. La taille d'un nom de lecteur, à savoir 2 caractères (cette information va néanmoins être récupérée dynamiquement avec strlen)
2. On sait qu'un caractère nul sépare chaque nom de lecteur
En utilisant strlen, on tombe sur 2, puisque cette fonction, comme printf, s'arrête au premier caractère nul. On ajoute ensuite 1 à cette longueur pour passer outre le caractère nul.
Cela fait avancer le pointeur de 3 caractères ... on se retrouve sur la première lettre du lecteur suivant, dont aucune des fonctions C ne soupçonnait l'existence !!

} // la fin de la boucle
Expliquons en quoi la condition *pch fonctionne : sur les systèmes Windows, on est limité à 26 lecteurs (autant que de lettres). Au maximum, cela fait donc 26 * (2 caractères + 1 nul) = 26*3 = 78 caractères. La quantité allouée, 1024 caractères, garantit donc qu'il restera des caractères nuls en fin de chaîne. Arrivé au dernier lecteur, l'itération se poursuit mais tombe sur un caractère nul. Cette valeur correspondant à 0, la boucle se termine.

Voilà, j'espère que tu as apprécié mon roman :lol:
C'était un petit peu long, mais je pense que j'ai tout dit ....

Enjoy C++ & Qt
Kwakanar

Tout d'abord, un caractère (ASCII) ne fait pas 2 octets mais un seulement.

Cette boucle imprime à l'écran toutes les chaines de caractères contenues dans le buffer, une chaine de caractère étant une suite d'octets suivie du caractère '\0'.
La boucle se termine à la première chaine vide, c.a.d. dès qu'elle rencontre dans le buffer deux '\0' consécutifs (ou un seul si c'est le premier octet du buffer).

Ca va mieux ?

Bon en fait, kwakanar m'a devancé d'une minute :)

Ce n'est pas plus mal, car son explication est beaucoup plus complète. Néanmoins, j'aimerais apporter une rectification.

Citation:

---

Envoyé par kwakanar

char *pch = szBuffer;
C'est une transformation de tableau en pointeur - exemple typique. Le pointeur est donc dirigé sur le premier caractère du tableau, et surtout on ne connaît plus la taille de ce dernier ! Ce qui va permettre au travers des manipulations qui suivent, de tromper les fonctions printf et strlen ...

---

En fait, on a autant d'informations sur la taille de pch que sur celle szBuffer, puisqu'ils ont la même valeur ! Il ne s'agit pas d'une transformation, il faut bien comprendre que pointeur et tableau c'est exactement la même chose.
Déclarer un tableau, c'est déclarer un pointeur et lui allouer en même temps une certaine quantité de mémoire.

Donc ces deux instructions sont équivalentes :

Code:

---

1 2 3 4

char szBuffer[1024]; char * pch = (char *) malloc(1024 * sizeof(char); //Version C char * pch = new char[1024]; //Version C++

---

On remarque d'ailleurs la similitude des déclaration en C++.

Et ce qu'on appelle la taille d'un tableau, c'est la mémoire qui lui a été allouée, et on ne la connait que si on a écrit nous même la déclaration/allocation ou si elle est dans une variable, sinon on a aucun moyen d'y avoir accès.


Et puis, je n'aime pas trop l'utilisation de l'expression "tromper les fonctions". Tu ne les trompes pas, elles font exactement ce qu'elles sont censés faire : compter le nombre d'octets précédant '\0'. Mais bon, ça c'est une histoire d'appellation, si tu préfères penser que tu les as trompées... libre à toi de le faire.

Voilà, j'espère que les précision apportées sont utiles (et justes !).
Strab

"Tout d'abord, un caractère (ASCII) ne fait pas 2 octets mais un seulement. "

Je crois qu'il y a le " : " qui suit la lettre du lecteur (c'est pas C mais C: pour le disque dur) ??

whouaou !!

vraiment tres sympa !!

en fait le format de sortie est :
A:\
C:\
etc...

il me semblait avoir compris que un caractere faisait 2 octets et 1 pour le reste.

bref

merci encore c'etait un plaisir de vous lire !!

Vérifie tout de même que le tableau est initialisé avec des caractères nuls, sinon, tu va direct au crash.

Citation:

---

Envoyé par kwakanar

Je crois qu'il y a le " : " qui suit la lettre du lecteur (c'est pas C mais C: pour le disque dur) ??

---

Oui, un nom de lecteur fait 2 caractères (voire trois apparemment), mais un caractère fait un octet. Son buffer fait 1024 caractères, donc 1024 octets, mais 1024 / 3 ~= 340 lecteurs.

Citation:

---

Envoyé par barbarello

il me semblait avoir compris que un caractere faisait 2 octets et 1 pour le reste.

---

Pas du tout en fait. Pour les types les plus courants, sur une machine 32 bits :
char = 1 octet
short = 2 octets
int = 4 octets
long = 8 octets
pointeur = 4 octets
Pour les nombres flottants, je ne suis pas sûr mais je crois que c'est :
float = 4 octets
double = 8 octets

Désolé si je n'avais pas été clair.
Strab

Ah tiens, à propos (je viens d'y penser :lol:) ...

Ceci :

Code:

---

pch = &pch[strlen(pch) + 1];

---

peut s'écrire plus joliment comme ça il me semble :

Code:

---

pch += strlen(pch) + 1;

---

Ce qui pait davantage ressortir le fait qu'on décale le pointeur de quelques octets vers la droite.

Voilou ...

Très juste.

J'en profite pour rappeler barbarello de penser à cliquer sur le bouton résolu si les réponses qu'il a obtenues le satisfont.

Strab

Citation:

---

while (*pch) {
Le début de la boucle. Tant que pch pointe sur un emplacement valide, c'est-à-dire que le caractère pointé n'est pas nul -> explications plus tard.

---

ou bien encore que l'objet qui est pointé par pch contient la valeur true non?

Toute valeur différente de 0 est équivalent à true.

#define FALSE 0
#define TRUE !FALSE

C'est bien evidement RESOLU merci encore de votre aide.

Je n'ai plus qu'a trouver ce bouton RESOLU ! :D

Merci

strab: tu t'es gouré, un long fait 4 octets sur une machine 32 bits (comme un int).
C'est le long long qui en fait 8...

Tout à la fin du thread, tu devrais avoir un bouton "RESOLU".