Les tableaux de pointeurs char*

Bonjour,

J'ai quelques questions théoriques à propos des tableaux de pointeurs de type char* ainsi que plus généralement les pointeurs char*.
Pour exemple dans cet énoncé simple:
Code:

1 2 3 4 5 6 7 8 9 using namespace::std int main() { char* pszArray; pszArray = "Developpez"; cout << &(*pszArray) << endl; return 0; }
Tout dabord je ne comprends pas comment cette chaîne de caractère est crée. Je veux dire, il n'y a pas eu d'allocation dynamique de mémoire, on a absolument rien renseigné et pour en savoir un peu plus j'ai voulu donc voir où était stocké cette chaîne dans la mémoire (d'où &(*pszArray)) mais ce qui en résulte est simplement l'affichage de la chaîne pointée par pszArray, à savoir "Developpez". A partir de là, je ne comprends plus rien! Où est stocké cette chaîne et, du coup, sur quoi le pointeur pointe-t-il?! Et ce quand bien même, en quoi est-ce différent d'un type string ?

Dans la continuité de ce questionnement, j'aimerais savoir comment il serait possible de remplir une chaîne pointée par un char* via un flux d'entré?
En effet, le code suivant plante:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 using namespace::std int main() { char* pszString; char* pszArray[0]; cin >> pszString; cin >> *(pszArray + 0); system("PAUSE"); return 0; }
Evidemment pour les deux cin. J'en conclu qu'il faut utiliser dans ce cas là une allocation dynamique, non? Mais je n'arrive pas à voir comment il est possible d'allouer de la mémoire pour un tableau de pointeurs char* (pszArray). Pourriez-vous, s'îl vous plait, m'aider dans cette démarche?

Merci d'avance et bonne fin de journée.

Citation:

Envoyé par Basmor

Code:

using namespace::std

Déjà là : c'est

Code:

using namespace std;

( On peut mettre les :: avant std mais ça n'apporte rien du tout. )

Citation:

Envoyé par Basmor

Tout dabord je ne comprends pas comment cette chaîne de caractère est crée. Je veux dire, il n'y a pas eu d'allocation dynamique de mémoire, on a absolument rien renseigné et pour en savoir un peu plus j'ai voulu donc voir où était stocké cette chaîne dans la mémoire (d'où &(*pszArray)) mais ce qui en résulte est simplement l'affichage de la chaîne pointée par pszArray, à savoir "Developpez". A partir de là, je ne comprends plus rien! Où est stocké cette chaîne et, du coup, sur quoi le pointeur pointe-t-il?! Et ce quand bien même, en quoi est-ce différent d'un type string ?

Ce qu'il se passe ici c'est qu'un objet temporaire est créé ( le "developpez" ) . ça fonctionne ici mais je ne garanti absolument que ça fonctionne ailleurs.
A noter aussi que &(*pszArray) est exactement équivalent à pszArray.

Citation:

Envoyé par Basmor

Evidemment pour les deux cin. J'en conclu qu'il faut utiliser dans ce cas là une allocation dynamique, non? Mais je n'arrive pas à voir comment il est possible d'allouer de la mémoire pour un tableau de pointeurs char* (pszArray). Pourriez-vous, s'îl vous plait, m'aider dans cette démarche?

Le meilleur conseille qu'on puisse te donner c'est d'utiliser les std::string. Sinon je pense que tout est dans la FAQ.

Citation:

Où est stocké cette chaîne

Dans la mémoire.

Citation:

sur quoi le pointeur pointe-t-il?

Sur le premier élément du tableau de caractère (ici "Developpez").

Citation:

en quoi est-ce différent d'un type string ?

C'est moins lisible, plus compliqué, on se plante plus facilement. string nous mâche le travail, et c'est que du bonheur. Si on reprend ton programme avec string :
Code:

1 2 3 4 5 6 7 8 using namespace std; int main() { string str = "Developpez"; cout << str << endl; // Affiche "Developpez" return 0; }
Plus simple non ?

Si toutefois tu veux vraiment comprendre les mécanismes des méandres des pointeurs en C++, cf les tutos et la FAQ de ce site.

Citation:
Envoyé par Basmor
Code:

1 2 3 4 5 6 7 8 using namespace::std int main() { char* pszArray; pszArray = "Developpez"; cout << &(*pszArray) << endl; return 0; }
Tout dabord je ne comprends pas comment cette chaîne de caractère est crée. Je veux dire, il n'y a pas eu d'allocation dynamique de mémoire, on a absolument rien renseigné
Cette chaîne est connue à la compilation, et donc à la compilation le compilateur peut décider que le programme réservera un emplacement mémoire pour la stocker

Citation:

Envoyé par Basmor

et pour en savoir un peu plus j'ai voulu donc voir où était stocké cette chaîne dans la mémoire (d'où &(*pszArray)) mais ce qui en résulte est simplement l'affichage de la chaîne pointée par pszArray, à savoir "Developpez".

Pour afficher de manière "brut de fonderie" un pointeur, il ne faut pas que ce soit un pointeur sur char, ils ont un traitement particulier :

Code:

cout << static_cast<void*>(pszArray) << endl; // Pouah, que c'est moche la notation psz !
Citation:
Envoyé par Basmor
Dans la continuité de ce questionnement, j'aimerais savoir comment il serait possible de remplir une chaîne pointée par un char* via un flux d'entré?
En effet, le code suivant plante:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 using namespace::std int main() { char* pszString; char* pszArray[0]; cin >> pszString; cin >> *(pszArray + 0); system("PAUSE"); return 0; }
Evidemment pour les deux cin. J'en conclu qu'il faut utiliser dans ce cas là une allocation dynamique, non? Mais je n'arrive pas à voir comment il est possible d'allouer de la mémoire pour un tableau de pointeurs char* (pszArray). Pourriez-vous, s'îl vous plait, m'aider dans cette démarche?
Il n'y a pas vraiment de bonne solution à mon sens (je veux dire, sauf à utiliser std::string). Le plus simple est d'allouer avant l'appel à cin assez de mémoire pour stocker les caractères et espérer que l'utilisateur n'entrera pas une chaîne trop grande... Bonjour la faille de sécurité.

L'alternative plus sure consiste à lire caractère par caractère dans un buffer, et si on se rend compte qu'on va dépasser la taille de celui-ci, réallouer dynamiquement un buffer plus grand, recopié ce qui a déjà été lu et recommencer. En gros, redévelopper std::string.

Quand je dois parler du C++ à des gens ayant une connaissance du C, j'utilise ce simple exemple du cin vers une string et je leur demande d'écrire l'équivalent en C pour leur montrer en quoi avoir un langage plus complexe peut conduire à avoir du code plus simple.

Citation:

Envoyé par Basmor

Bonjour,

Salut, et bienvenue sur le forum
J'ai quelques questions théoriques à propos des tableaux de pointeurs de type char* ainsi que plus généralement les pointeurs char*.
Pour exemple dans cet énoncé simple:
Code:

1 2 3 4 5 using namespace::std int main() { char* pszArray;
[/QUOTE]
Le plus facile pour bien comprendre consiste sans doute à lire le code de droite à gauche...

Ainsi, pszArray est le nom d'une variable qui est un pointeur ( * ) de type "char" (caractère)

Citation:

Code:

pszArray = "Developpez";

Cette ligne de code est particulièrement dangereuse, mais j'en parlerai au moment de répondra à ta question qui concerne l'emplacement de Developpez ;)

Citation:

Code:

cout << &(*pszArray) << endl;

A tu réfléchi à ce que fait ce & (*pszArray) :question:

Nous avons dit que pszArray est... un pointeur.

L'étoile que tu as écrite signifie "prend ce qui est pointé par le pointeur" (en fait "prend ce qui se trouve à l'adresse indiquée par le pointeur") et l'esperluette " & " signifie "prend l'adressse de..."

N'as tu pas l'étrange impression de te faire du mal en voulant prendre l'adresse de ce qui se trouve à l'adresse indiquée par pszArray :question:

Citation:

Tout dabord je ne comprends pas comment cette chaîne de caractère est crée.

Cette chaine prend place dans le segment data du programme...

Il s'agit, simplement, d'une partie de la mémoire dans laquelle iront se placer toutes les constantes littérales utilisée.

C'est le compilateur qui se charge de placer toutes les constantes littérales dans cette partie de la mémoire ;)

Citation:

Je veux dire, il n'y a pas eu d'allocation dynamique de mémoire,

Il n'y en a absolument pas besoin, parce que le compilateur sait, pour les constantes, calculer de lui-même le nombre de byte à utiliser :D

Citation:

on a absolument rien renseigné et pour en savoir un peu plus j'ai voulu donc voir où était stocké cette chaîne dans la mémoire (d'où &(*pszArray)) mais ce qui en résulte est simplement l'affichage de la chaîne pointée par pszArray, à savoir "Developpez". A partir de là, je ne comprends plus rien! Où est stocké cette chaîne et, du coup, sur quoi le pointeur pointe-t-il?!

C'est normal, parce que toute donnée (y compris sur le disque dur ou n'importe quel système de stockage) est accessible par... une adresse qui lui est propre...

Le fait qu'elle se trouve dans le segment data n'y change rien, hormis le fait que la donnée ne peut pas être modifiée.

Mais c'est ce point particulier qui est dangereux: il t'est strictement interdit, au cours de l'exécution du programme, d'essayer de remplacer Developpez par Enveloppez :D

Pour pouvoir envisager un tel changement, il faut veiller à ce que pszArray contienne une adresse mémoire... accessible en lecture/écriture, disposant de suffisamment d'espace contigu pour contenir les 9 caractères significatifs du mot Developpez plus un caractère nul '\0' qui représente la fin de la chaine.

En outre, il faut organiser la copie des 9 caractères significatifs du mot du segment data vers la mémoire qui aura été allouée pour les recevoir.

Cela prendrait la forme de
Code:

1 2 3 pszArray = new char[10]; strncpy("Developpez",pszArray,10);
Citation:

Et ce quand bien même, en quoi est-ce différent d'un type string ?

La différence, c'est que les chaines de caractères "C style" qui ne sont que des tableaux de caractères terminés par un '\0' t'obligent à gérer toi même l'espace mémoire que tu prévois pour contenir la chaine, et à effectuer toi-même la copie de contenu, avec tous les risques inhérents au fait que tu risque toujours... de ne pas avoir prévu assez d'espace (si tant est que tu puisse décider d'en allouer plus) ou d"'oublier" de libérer un espace que tu n'utilise plus

Par contre, la classe string connait en permanence le nombre de caractères qu'elle utilise et le nombre qu'elle peut encore rajouter avant de devoir procéder à une modification de sa taille maximale.

Elle est capable de gérer la copie de son contenu, et le mieux de l'histoire, c'est qu'elle le fait de manière tout à fait transparente pour toi (tu n'as absolument pas à t'inquiéter de tout cela) :D

Citation:

Dans la continuité de ce questionnement, j'aimerais savoir comment il serait possible de remplir une chaîne pointée par un char* via un flux d'entré?

Peut etre (en fait, non, j'en suis persuadé :D) que le mieux est, tout simplement, d'utiliser la classe string partout où tu le peux :D

De toutes manières, si tu as vraiment besoin d'une chaines de caractères "C style", tu peux toujours en récupérer une grâce à la fonction membre c_str() ;)
En effet, le code suivant plante:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 using namespace::std int main() { char* pszString; char* pszArray[0]; cin >> pszString; cin >> *(pszArray + 0); system("PAUSE"); return 0; }
Evidemment pour les deux cin. [/QUOTE]C'est normal que le code platnte:
pszString est un pointeur vers des variables de types char qui pointe sur... strictement tout ou n'importe quoi (l'adresse qu'il contient est le résultat des crasse laissée par la dernière utilisation de la mémoire).

Or, il y a de fortes chances que cette adresse renvoie à... une donnée qui n'est certainement pas prête à recevoir des données :D

La première chose à faire pour pouvoir utiliser pszString est donc... d'indiquer très clairement le nombre de caractères contigus que tu veux utiliser, soit de manière statique (comprend: sans avoir recours à l'allocation dynamique de la mémoire), soit en ayant recours à l'allocation dynamique, et en étant toujours susceptible de te trouver dans une situation où tu aurais prévu de permettre la saisie de N caractères alors que l'utilisateur en introduira... N+1, ce qui risque de provoquer des problèmes sans nom :D

La déclaration n'ayant pas recours à l'allocation dynamique pourrait prendre la forme de

Code:

char pszString[11];

qui se lirait sous la forme de "je déclare un tableau (les crochets permettant de représenter un tableau, ou, plus précisément, l'indice des éléments se trouvant dans un tableau) de type char et que je nomme pszString, et qui aurait pour résultat de permettre la saisie de 10 caractères significatifs en gardant la place pour le '\0' terminal.

Soit, tu peux avoir recours à l'allocation dynamique (qui te permet, le cas échéans, de décider de modifier la taille du tableau) sous la forme de

Code:

char *pszString=new char[11];

Quant à pszArray, c'est encore pire...

Tu déclares un tableau devant contenir des pointeurs vers des données de type char, mais qui doit contenir... 0 éléments :aie:

Autrement dit, tu déclares un tableau de pointeurs vers des données de type char qui ne peut contenir... aucun pointeur... Cherchez l'erreur :D

Et, même si tu modifie un peu le code en

Code:

char *pszArray[10]; /* je prévois de stocker 10 chaines de caractères */

il faudra encore... veiller à allouer l'espace suffisant pour contenir chacune de ces chaines, parce qu'une chaine de caractères "C style" n'est jamais... qu'un tableau de cararctères :D (terminé par un '\0', est-il encore besoin de le rappeler)

Ou alors, la bérézina consiste à souhaiter être en mesure de disposer d'un nombre inconnu de chaines de caractères pouvant chacune contenir un nombre quelconque de caractères, et là, pour y arriver (à la manière C style), il faudrait commencer à jouer avec... des pointeurs de pointeurs...

En effet, lorsque tu déclares un tableau sous la forme de

Code:

int tab[10];

tab (sans les crochets) est à considérer comme... un pointeur sur le premier élément du tableau (celui se trouvant à l'indice 0)

Citation:

J'en conclu qu'il faut utiliser dans ce cas là une allocation dynamique, non?

Pas forcément avec de l'allocation dynamique, mais très certainement en comprenant la signification de chacun des symboles que tu utilise...

En effet, lorsque tu écris:

Code:

char * str;

tu ne fait que déclarer un pointeur vers des données de type char (autrement dit, une variable dont la valeur représente l'adresse à laquelle tu devrais pouvoir trouver une variable de type char)

alors que quand tu écris:

Code:

char str[10];

tu déclare un tableau de dix caractères contigus en mémoire et str représente... l'adresse à laquelle se trouve le premier caractère (celui se trouvant à l'index 0)

Si tu veux gérer un tableau de chaines de caractères, tu peux très bien envisager d'écrire

Code:

char tabStr[10][15]

qui va déclarer un tableau contenant dix tableaux eux même composés de 15 caractères (14 caractères significatifs), autrement dit, un tableau de dix chaines de 14 caractères chacune.

Si tu veux utiliser l'allocation dynamique, le code devient:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 /* soit on effectue directement l'allocation dynamique comme dans les * exemples précédents, soit en prend la précaution d'initialiser * le pointeur à NULL qui représente une adresse invalide et facile * à tester */ char *str = NULL; str=new char[10]; /*...*/ /* il ne faut pas oublier de libérer la mémoire allouée dynamiquement quand * on n'en a plus besoin */ delete str; /* et, par sécurité, de remettre le pointeur à NULL */ str = NULL;
ou, pour un tableau de chaines de caractères "C style", sous la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 /* il faut un tableau de tableau, autrement dit l'identifiant est... l'adresse à * laquelle nous trouverons l'adresse du premier caractère de la première * chaine (c'est à dire, un pointeur de pointeur) */ char **tabstr; /* il faut commencer par allouer dynamiquement la mémoire pour le * contenant (pour le tableau), il doit contenir... des pointeurs vers des * caractères */ tabstr= new char*[10]; /* puis il faut allouer la mémoire pour chacune des chaines de caractères */ for(size_t i=0;i<10;++i) tabstr[i]=new char[15]; /*...*/ /* et bien sur, il ne faut pas oublier de libérer la mémoire lorsque l'on n'en a * plus besoin... * d'abord le contenu (les différentes chaines) */ for(size_t i=0;i<10;++i) delete tabstr[i]; /* puis le contenu */ delete tabstr; /* et, par sécurité, nous faisons pointer tabstr vers une adresse connue pour * être invalide */ tabstr = NULL;
Et, quoi qu'il en soit, l'idéal est d'éviter comme la peste les possibilités qui sont strictement issues du C et de leur préférer les possibilités offertes par le C++ et qui lui sont propres.

Ainsi, plutôt que de t'amuser avec des char *, char[] pour représenter des chaines de caractères, l'idéal sera toujours de manipuler... des string, qui sont disponibles (comme tout ce qui est fourni par le standard, ou presque) dans l'espace de noms std par la seule inclusion de l'en-tête <string>

Et, plutôt que de t'amuser à gérer d'une manière ou d'une autre toi-même des tableaux d'éléments contigus en mémoire, l'idéal est de recourir à la classe fournie par le standard qui agit justement comme un tableau classique: la classe vector, également disponible dans l'espace de noms std, mais nécessitant cette fois-ci l'inclusion de l'en-tête <vector>.

Tu pourrais alors envisager un code proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 #include <iostream> /* nécessaire pour les entrées/sorties standard*/ #include <string> /* nécessaire pour les chaines de caractères */ #include <vector> /* nécessaire pour les tableaux d'éléments contigus */ /* on pourrait rajouter la directive using namespace std; * qui nous éviterait d'avoir à écrire sans cesse std::... * mais on peut faire sans :D */ int main() { /* déclarons un tableau de chaines de caractères */ std::vector<std::string> strTab; /* demandons dix fois à l'utilisateur d'introduire un mot * nous aurions pu lui demander 10 000 fois... que cela aurait encore * été pareil :D * mais l'utilisateur se serait sans doute lassé avant l'ordinateur :D */ for(size_t i=0;i<10;++i) { /* il nous faut quand même une chaine pour récupérer l'entrée */ std::string str; /* et soyons sympa, indiquons à l'utilisateur ce que l'on attend * de lui :D * * le premier mot sera indiqué par le numéro 1... or on compte à * partir de 0 ici :D */ std::cout<<"Veuillez introduire le mot "<<i+1<<":"<<std::endl; std::cin>>str; /* et introduisons cette chaine dans le tableau */ strTab.push_back(str); } /* il est temps d'afficher tous les mots... ici, un par ligne fera l'affaire :D */ std::cout<<"Vous avez introduit les mots :"<<std::endl; /* il existe quantité de possibilités de provoquer l'affichage... * mais une simple boucle peut très bien faire l'affaire :D * Ici, je vais cependant utiliser la fonction size() dont dispose * la classe vector pour savoir quand m'arrêter :D */ for(size_t i=0;i<strTab.size();++i) std::cout<<strTab[i]<<std::endl; /* ce qui est bien, c'est que l'on n'a rien à faire pour libérer la mémoire * avant de quitter l'application :D */ return 0; }
Et je présumes que tu l'aura remarqué: Si le code semble énorme, c'est essentiellement à cause des commentaires que j'ai placés :D