Structure de donnée et tableaux

Version imprimable

Bonjour !

Pour commencer, je suis novice en C++, j'ai lu des cours en C mais n'ai jamais tenu de réel projet, manque d'idée. Cependant, ayant assez de connaissances en C, je me suis intéressé au C++ près d'un an après et me voici aux structures de données.

J'ai un lèger souci avec ce code:
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 #include <iostream> #include <string> using namespace std; struct foo{ string x; string y; } *pointer; int main () { short i, a; cout << "Longueur du tableaux : "; cin >> a; pointer = new foo [a]; for(i = 0 ; i < a ; i++){ cout << "Entrez une phrase pour tableau 1 array " << i << " : "; getline(cin, pointer[i].x); } for(i = 0 ; i < a ; i++){ cout << "Entrez une phrase pour tableau 2 array " << i << " : "; getline(cin, pointer[i].y); } for(i = 0 ; i < a ; i++){ cout << pointer[i].x << endl; } for(i = 0 ; i < a ; i++){ cout << pointer[i].y << endl; } return 0; }
Comme vous pouvez le voir, je créer un objet pointer qui est donc un pointeur.

Par la suite, je demande à l'utilisateur quelle taille doivent faire les tableaux de string pointer[].x et pointer[].y

Ensuite on remplit les tableaux.
Et on finit par afficher leur contenu.

Seulement, voici ce que j'obtient en sortie, lors des tests:

Entrez une phrase pour tableau 1 array 0 : Entrez une phrase pour tableau 1 array 1 : 0
Entrez une phrase pour tableau 2 array 0 : 1
Entrez une phrase pour tableau 2 array 1 : 2

0
1
2

Ce qui m'embête c'est qu je ne peux pas entrer quelquechose dans la première case du premier tableau...

Merci d'avance.

21/06/2009, 15h30
Goten
Essaye en purgeant le buffer clavier...

ie comme ça :
Code:

1 2 std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
Juste après la lecture sur le cin.

ps : ça implique d'inclure limits ;).

Edit: j'ai rien dit...

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
#include <iostream>
#include <string>
#include <limits>
 
using namespace std;
 
struct foo{
  string x;
  string y;
} *pointer;
 
int main ()
{
  short i, a;
 
  cout << "Longueur du tableaux : ";
  cin >> a;
  pointer = new foo [a];
 
  cin.ignore(numeric_limits<streamsize>::max(), '\n');
 
  for(i = 0 ; i < a ; i++){
    cout << "Entrez une phrase pour tableau 1 array " << i << " : ";
    getline(cin, pointer[i].x);
  }
 
  for(i = 0 ; i < a ; i++){
    cout << "Entrez une phrase pour tableau 2 array " << i << " : ";
    getline(cin, pointer[i].y);
  }
 
  for(i = 0 ; i < a ; i++){
    cout << pointer[i].x << endl;
  }
 
  for(i = 0 ; i < a ; i++){
    cout << pointer[i].y << endl;
  }
  return 0;
}

Maintenant ça fonctionne.

21/06/2009, 19h00
koala01
Salut,

Ceci dit, l'utilisation de variables globales est généralement largement déconseillée... surtout si, en plus, il s'agit de pointeurs(parce que l'utilisation de pointeur est, elle aussi, fortement déconseillée :aie)

Veux tu la preuve de ce que j'avance:question:

Sur un code qui ne fait que quelques lignes, tu arrive déjà a obtenir une fuite mémoire, simplement parce que tu as pensé à allouer correctement la mémoire pour ton pointeur, mais que tu n'a pensé nulle part à... libérer cette mémoire :aie:

Et cela nous amène tout naturellement à l'exposé de la raison qui rend mon conseil si important:

Déjà, chaque fonction est susceptible de modifier une variable globale...

Tu ne peux donc pas partir de la moindre présomption concernant cette variable au moment où tu décid de la manipuler

De plus, comme il s'agit d'un pointeur, toute fonction qui utilise la variable est susceptible:
- de décider d'effectuer une allocation dynamique de l'objet, alors que ce n'est pas *forcément* nécessaire ni indiqué
- de décider d'effectuer une libération de la mémoire, alors que ce n'est pas *forcément* nécessaire ni indiqué
Le résultat, si l'une de ces situations survient sera, au mieux (dans le premier cas) une fuite mémoire, au pire (dans le second cas) une double libération de la mémoire).

Au final, pour essayer de contourner ce type de problème, tu devra non seulement adopter une politique clairement défensive (consistant à vérifier en priorité et à tout moment si le pointeur est valide), mais aussi prendre des habitudes contraignantes de remise du pointeur à NULL chaque fois qu'une fonction libérera la mémoire allouée à la variable globale en question.

Peut être pourrions nous t'indiquer la meilleure solution si tu nous disais dans quelle circonstances tu souhaite utiliser ta variable globale :question:
24/06/2009, 22h15
zebulondu54

Ah... les variables globales. Je les avaient oubliées celle-là !
C'est corrigé, je ne sais pas pourquoi le l'ai mise là tiens...

A vrai dire, ce que j'ai codé c'était juste pour m'exercer avec la manipulation des structures additionnées de pointeurs...

J'ai effectivement zapé la libération de mémoire !
Dans le code je ne sais pas comment la libèrer... peux-tu m'aider ?
25/06/2009, 18h34
Davidbrcz

C'est un tableau, alloué par new[], donc un delete[] pointer; suffit.

Après, dans du code réel, il faut utiliser std::vector à la place de ce genre d'horreur.
25/06/2009, 18h57
zebulondu54

vector ? Pourquoi l'utiliser et surtout à la place de quoi ? De l'allocation dynamique avec new ?
25/06/2009, 19h03
koala01

Citation:

Envoyé par zebulondu54

vector ? Pourquoi l'utiliser et surtout à la place de quoi ? De l'allocation dynamique avec new ?

Si on part sur une allocation dynamique de la mémoire, effectivement, un std::vector semble largement plus intéressant à utiliser...

Si le tableau ne doit jamais avoir qu'une taille clairement définie à l'avance et qu'il n'est pas nécessaire de la modifier au long de l'application, un tableau "C style" ou un boost::array peut faire l'affaire ;)

Citation:

Envoyé par zebulondu54

vector ? Pourquoi l'utiliser et surtout à la place de quoi ? De l'allocation dynamique avec new ?

Plus de problème de gestion de la mémoire, enveloppe RAII sur tes données (comprendre que la destruction se fait automatiquement)
Exemple:
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 #include <iostream> #include <string> #include <vector> #include <limits> using namespace std; struct foo{ string x; string y; }; int main () { short i, a; cout << "Longueur du tableaux : "; cin >> a; std::vector<foo> pointer(a); //ici on réserve un tableau pour a objet, mais on pourrait en ajouter au fur et à mesure. cin.ignore(numeric_limits<streamsize>::max(), '\n'); for(i = 0 ; i < a ; i++){ cout << "Entrez une phrase pour tableau 1 array " << i << " : "; getline(cin, pointer[i].x); } for(i = 0 ; i < a ; i++){ cout << "Entrez une phrase pour tableau 2 array " << i << " : "; getline(cin, pointer[i].y); } for(i = 0 ; i < a ; i++){ cout << pointer[i].x << endl; } for(i = 0 ; i < a ; i++){ cout << pointer[i].y << endl; } return 0; }
Les vectors, c'est bon, il faut en manger (et la STl en général) car ca offrent plein de possibilité. Ajout d'élement simplifié, accès à la taille de la collection,...

Recherche sur google et une fois que tu y as gouté, tu ne t'en passes plus.

26/06/2009, 00h09
koala01

Citation:

Envoyé par fcharton

C'est peut être pas la caractéristique que je mettrais en premier, ça...

Ce que je mettrais en premier, c'est en fait le RAII (et l'explication qui va avec :D)
26/06/2009, 18h34
zebulondu54

Ulaa... je crois que je vais finir le tuto en C++ de cplusplus.com et après je reviendrais lire tout ce qui a été dit...

Ma fois merci beaucoup ! Sachez que tout ce que vous avez dit ne sera pas perdu ;)
26/06/2009, 20h27
Ubiquité

Si je peux me permettre de scouater momentanément le topic pour poser une question :

Quand vous dites qu'un std::vector garanti l'appel du destructeur c'est par rapport à un tableau style C dynamique ?
26/06/2009, 20h29
koala01

Citation:

Envoyé par Ubiquité

Si je peux me permettre de scouater momentanément le topic pour poser une question :

Quand vous dites qu'un std::vector garanti l'appel du destructeur c'est par rapport à un tableau style C dynamique ?

Oui, et de manière générale une gestion "saine" de la mémoire allouée dynamiquement (et de manière transparente pour ce qui touche à la STL)