Discussion :

[Spir]

Que faut il utiliser pour les collections en C++?

std::tr1::unordered_map<>
std::vector
std::list
??
Je fais un logiciel de gestion pour un biblioth�que.
On m'a dit que la class vector n'�tait pas bien pour g�rer une collection d'objet:

En l'occurence, pour un logiciel de gestion type biblioth�que,le type vector n'a pas d'int�r�t, vu que tu vas faire des insertions/suppression, et que tu vas sans doute acc�der aux objects par autre chose qu'un simple num�ro (� par l'ISDN, mais tu ne vas pas le stocker sur des entiers cons�cutifs).

Que me conseiller vous d'utiliser?

[Luc Hermitte]

Si tu n'as pas beaucoup d'�l�ments, cela ne devrait pas faire une grande diff�rence d'autant que tu risques de vouloir trier suivant plusieurs crit�res � un moment ou un autre.
Tes objets seront tr�s probablement manipul�s par pointeur (s�mantique de r�f�rence), donc faire des insertions reviendrait juste � d�placer des (/smart-)pointeurs.

Les tables de hashages pourquoi pas pour les syst�mes de dimension interm�diaires. Je regarderai quand m�me du c�t� de boost.multi_index pour les multi-indexage.

Si tu as beaucoup d'�l�ments, utiliser une vraie base de donn�es serait plus conseill�.

[Spir]

Si tu n'as pas beaucoup d'�l�ments, cela ne devrait pas faire une grande diff�rence d'autant que tu risques de vouloir trier suivant plusieurs crit�res � un moment ou un autre.
Tes objets seront tr�s probablement manipul�s par pointeur (s�mantique de r�f�rence), donc faire des insertions reviendrait juste � d�placer des (/smart-)pointeurs.

Les tables de hashages pourquoi pas pour les syst�mes de dimension interm�diaires. Je regarderai quand m�me du c�t� de boost.multi_index pour les multi-indexage.

Si tu as beaucoup d'�l�ments, utiliser une vraie base de donn�es serait plus conseill�.

Je n'ai pas bien compris ce que tu m'a dit. Je d�bute en C++.
En gros tu me conseil d'utiliser une liste chain�?
pour ce qui est de la bdd je ne peux pas. Pas le droit (c'est dans le cadre d'un projet d'�tude). J'utilise des fichiers.

[Luc Hermitte]

Non, pas une liste chain�e. Une table de hashage, std::tr1::unordered_map<> en est une dans le principe je crois bien.

Il est d'ailleurs surprenant qu'on t'en parle si tu d�butes juste.
Sinon, je conseille le vecteur de pointeurs dans un premier temps. Et si vraiment il y a trop d'�l�ments, migrer vers autre chose -> std::tr1::unordered_map<> ou std::map si avoir un index a un sens.

[Spir]

mh mh ca � l'air compliqu� tout ca (le nom d�route). Avec java j'utilisais les vecteur c'�tait cool. Mais apparement en C++ c'est diff�rent.

[JolyLoic]

Bof, pas tellement diff�rent, une collection reste une collection quel que soit le langage. Et coup de bol, j'ai bien l'impression que ce que Java appelle Vector correspond � ce que C++ appelle std::vector. La seule diff�rence est qu'en Java, un Vector doit �tre semblable en performances � un vector de pointeurs en C++.

Et dans les deux cas, ce n'est pas le conteneur appropri� pour ins�rer/supprimer des �l�ments au milieu (complexit� O(n)), ou effectuer des recherches index�es, m�me si pour des conteneurs de patite taille la diff�rence ne se voit probablement pas.

<mode troll>
Peut �tre que la principale diff�rence est qu'en C++ les gens font attention � la complexit� des algorithmes qu'ils utilisent
</mode>

[Spir]

Bon donc je vais utiliser les vecteur alors...

[Kaktus]

C'est pratiquement comme en Java.. Sauf que en C++, on a plus de possibilit�s.
On peut les parcourir par it�rateurs (comme Java).


vector -> Excellent pour les s�lections, mauvais pour les insertions. Possibilit� d'acc�s direct. Le plus utilis�, le plus proche des tableaux classiques, sauf qu'il peut changer de taille.

list-> Excellent en insertion, pas d'acc�s direct sauf le premier membre.
Possibilit� de tri.

deque-> un mix des deux, avec acc�s direct autoris�, moyen en insertion, moyen en s�lection. Rarement utilis�.

map-> c'est exactement comme un r�pertoire.
par exemple, map<int,string> te permet de trouver le string correspondant � un int donn�.


Donc :
- Si tu as peu d'insertions et beaucoup de s�lection, le vector est indiqu�
- Si tu n'as pas d'acc�s direct , la list.
- et map pour des trucs genre r�pertoires.

[Spir]

Dans mon cas je vais faire
des insertions
des tris (apr�s insertion ou avant)
acc�s direct? je ne pense pas. Je pense faire des recherches s�quencielles pour ce qui est des acc�s.

EDIT: heu pour les acc�s direct j'imagine que tu parle de la m�thode operator []... Danc ce cas ouais j'ai besoin d'avoir des acc�s direct.

Si c'est comme en java y pas de souci pour l'insertion dans les vecteurs...

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

monVecteur.InsertElementAt( i, monObjet );

je crois que c'�tait comme ca en java.

[JolyLoic]

On peut effectivement ins�rer, et �a marche, comme en Java. Ce n'est par contre pas tr�s efficace sur ce type de collection, comme en Java.

Il n'y a aucune collection qui soit hyper efficace pour toutes les op�rations que tu comptes faire. Alors, plusieurs possibilit�s :
- Une op�ration est moins courante qu'une autre : dis nous laquelle, on pourra te conseiller la bonne collection
- Tu te moques des performances, de toute fa�on, la liste restera de petite taille : continue � utiliser vector
- Parfois des solutions o� on g�re en parall�le les donn�es dans plusieurs collections diff�rentes sont int�ressantes.

[Spir]

On peut effectivement ins�rer, et �a marche, comme en Java. Ce n'est par contre pas tr�s efficace sur ce type de collection, comme en Java.

Il n'y a aucune collection qui soit hyper efficace pour toutes les op�rations que tu comptes faire. Alors, plusieurs possibilit�s :
- Une op�ration est moins courante qu'une autre : dis nous laquelle, on pourra te conseiller la bonne collection
- Tu te moques des performances, de toute fa�on, la liste restera de petite taille : continue � utiliser vector
- Parfois des solutions o� on g�re en parall�le les donn�es dans plusieurs collections diff�rentes sont int�ressantes.

Voil�. Je me fou des performance : c'est un prog. pour un projet scolaire... donc peu de donn�es. on ne recherche pas la performance.
Je vais utiliser en effet plusieurs collections.
Mon prog. permet de g�rer une biblioth�que :

• *Collection Adh�rent
  *Collection Ouvrage
  *Collection Emprunt (ouvrage/Adh�rent)
  *R�servation
  *...

Donc je pense que je vais utiliser les vector.

[Spir]

Hello, finalement je suis oblig�, c'est impos�... je dois utilisez les listes cha�n�es pour faire mes collections!
Je me suis donc mis dans la t�te de faire une class template Liste qui cr�� une liste chain� d'un type donn�.
Mais je n'y arrive pas. J'ai beucoup de souci de compilation au niveau de mes malloc. Pouvez vous m'aider??

Voici ma classe :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
#ifndef LISTE_H
#define LISTE_H
 
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream.h>
 
template <class T>
class Liste
{
	typedef struct listeC
    {
		T _element ;
		struct liste *precedent ;
		struct liste *suivant ;
    }liste;	
 
	liste *debut ;	
	int nbElement ;
 
public:
	Liste() ;
	Liste( const T &element ) ;
 
	int ajouteElement( const T &element ) ;
 
	int getNbElement() ;
 
};
 
template <class T>
Liste<T>::Liste()
{
	debut = NULL ;
	nbElement = 0 ;
}
 
template <class T>
Liste<T>::Liste( const T &element )
{
	debut = new T; 
 
	_element = element ;
	debut.precedent = NULL ;
	debut.suivant = NULL ;
 
	nbElement = 1;
}
 
template <class T>
int Liste<T>::ajouteElement( const T &element )
{
	liste *courant ;
 
	if( debut == NULL )
	{
		debut = new T; 
		_element = element ;
		nbElement = 1;
	}
	else
	{
		while( courant->suivant != debut )
		{
			courant = courant->suivant ;
		}
		if( courant->suivant == debut )
		{
			courant->suivant = new T; 
			courant->suivant->_element = element;
			courant->suivant->suivant = debut;
			debut->precedent = courant->suivant;
		}
	}
	return 1;
}
 
template <class T>
int Liste<T>::getNbElement()
{
	return nbElement;
}
 
#endif

Dans ma classe pour l'instant j'ai donc fait :

• un conctructeur
  un conctructeur de recopie
  une m�thode permettant d'ajouter une �l�ment dans ma liste cha�n�
  un accesseur qui retourne le nombre d'�l�ment de ma liste cha�n�

J'ai en attribut de classe une structure : ma liste chain�
l'adresse du d�but de ma liste chain�
et un entier qui correspond au nombre d'�l�ment de ma liste chain�.
Ma liste chain� est une liste doublement chain� avec un lien vers le chainon suivant et un lien vers le chainon pr�c�dent.
C'est donc une liste chain� circulaire.

[Spir]

Cette ligne de code pose probl�me par exemple :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
 
debut = new Liste<T>;

Erreur :
error C2440: '=' : cannot convert from 'class Liste<class Emprunteur> *' to 'struct Liste<class Emprunteur>::listeC *'

En fait dans ce cas l� je fait une liste chain� contenant des objets Emprunteur

[Spir]

Voil� j'ai pass� mon aprem dessu...
Tout fonctionne sauf un petit d�tail...
Voici le code :

#ifndef LISTE_H
#define LISTE_H

#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <string.h>

template <class T>
class Cellule
{
public:
T _valeur ;
Cellule *_suivant ;

Cellule() ;
Cellule( const T &valeur ) ;
~Cellule() ;

//Accesseur
T getValeur() ;
Cellule<T> *getSuivant() ;

//Modificateur
void setSuivant( Cellule<T> * cellSuivante ) ;
void supprSuivant() ;
};

template <class T>
Cellule<T>::Cellule()
{
_suivant = NULL ;
}

template <class T>
Cellule<T>::Cellule( const T &valeur )
{
_valeur = valeur ;
_suivant = NULL ;
}

template <class T>
Cellule<T>::~Cellule()
{
if( _suivant != NULL )
{
_suivant->~Cellule() ;
}
free( _suivant ) ;
}

template <class T>
T Cellule<T>::getValeur()
{
return( _valeur ) ;
}

template <class T>
Cellule<T> *Cellule<T>::getSuivant()
{
return( _suivant );
}

template <class T>
void Cellule<T>::setSuivant( Cellule<T> * cellSuivante )
{
if( cellSuivante == NULL )
{
_suivant=NULL ;
}
else
{
_suivant = new Cellule ;
*_suivant = *cellSuivante ;
}
}

template <class T>
void Cellule<T>::supprSuivant()
{
_suivant->~Cellule() ;
free( _suivant ) ;
}

//------------------------------------------

template <class T>
class Liste
{
public:
Cellule<T> **_debut ;
int _nbElement ;

Liste() ;
Liste( const T &element ) ;
Liste( const Liste &uneListe ) ;

~Liste() ;

//Accesseurs
int getNbElements () ;
T * operator []( int position );
void insertionPosition( int position, const T &element ) ;

//Modificateur
void insererElementA( int position, const T &element ) ;
int *rechercherElement( const T &element ) ;

//Lecture / ecriture dans les fichiers
int ecriture( char *chemin_fichier );
int lecture( char *chemin_fichier );


private :
T * getElement( int position );
};

template <class T>
Liste<T>::Liste()
{
_debut=NULL ;
}

template <class T>
Liste<T>::Liste( const T &element )
{
_debut = new Cellule<T>(element) ;
}

template <class T>
Liste<T>::Liste( const Liste &uneListe )
{
Cellule<T> *courant ;
int i ;

if ( uneListe._debut != NULL )
{
_debut = new Cellule<T>( uneListe._debut->getValeur() ) ;
_debut.setSuivant( uneListe_debut->getSuivant() ) ;

courant = uneListe._debut->getSuivant() ;
i = 1 ;

while ( courant != NULL )
{
this->insererElementA ( ++ i, courant._debut->getValeur() )
courant = courant->getSuivant() ;
}
}
else
{
_debut = NULL ;
}
}

template <class T>
Liste<T>::~Liste()
{
if( _debut!=NULL )
{
_debut->~Cellule() ;
}
free( _debut ) ;
}

template <class T>
T * Liste<T>::operator []( int position )
{
int i ;
Cellule<T> *courant ;
T *element ;

i = 1 ;
courant = *_debut ;
element = NULL ;

if( position > 0 )
{
while( courant != NULL && i<position )
{
courant = courant->getSuivant() ;
i ++ ;
}
if(courant!=NULL)
{
element = new T ;
*element = courant->getValeur() ;
}
else
{
printf( "erreur" ) ;
}
}
else
{
*element = *_debut->getValeur() ;
}
return( element ) ;
}

template <class T>
T *Liste<T>::getElement( int position )
{
int i ;
Cellule<T> *courant ;
T *element ;

i = 1 ;
courant = _debut ;
element = NULL ;

if( position > 0 )
{
while( courant != NULL && i<position)
{
courant = courant->getSuivant() ;
i++ ;
}
if(courant!=NULL)
{
element = new T ;
*element = courant->getValeur() ;
}
else
{
printf("erreur") ;
}
}
else
{
*element = _debut->getValeur() ;
}
return( element ) ;
}

template <class T>
void Liste<T>::insererElementA( int position, const T &element )
{
int i ;
Cellule<T> nouvelElement( element ), *courant ;
if( position==0 )
{
if( getNbElements()!=0 )
{
nouvelElement.setSuivant( *_debut ) ;
}
else
{
nouvelElement.setSuivant( NULL ) ;
}
*_debut = new Cellule<T> ;
*_debut = &nouvelElement ;
}
else if( position > 0 )
{
if( position >= ( getNbElements() ) ) //Insertion � la fin
{
courant = *_debut ;
while( courant->getSuivant() != NULL )
{
courant = courant->getSuivant() ;
}
if( courant->getSuivant() == NULL )
{
courant->setSuivant( &nouvelElement ) ;
}
else
{
printf( "erreur : Insertion � la fin \n" ) ;
}
}
else //insertion dans la liste
{
courant = *_debut ;
i = 0 ;
while( courant->getSuivant() != NULL && i != position )
{
courant = courant->getSuivant() ;
}
if( courant->getSuivant() != NULL && i == position )
{
nouvelElement.setSuivant( courant->getSuivant() );
courant->setSuivant( &nouvelElement ) ;
}
else
{
printf( "erreur : insertion dans la liste\n" ) ;
}
}
}
}

template <class T>
int Liste<T>:: getNbElements ()
{
Cellule<T> *courant ;
courant = *_debut ;
int i =0 ;

while ( courant != NULL )
{
courant = courant->getSuivant() ;
i ++ ;
}
return i ;
}

template <class T>
int *Liste<T>::rechercherElement( const T &element )
{
int *position, n, i ;

position = NULL ;
i = 1 ;

n = getNbElements();

while( position == NULL && i <= n )
{
if( *getElement( i ) == element )
{
position = new int ;
*position = i ;
}
i ++ ;
}

return( position ) ;
}

template <class T>
int Liste<T>::ecriture( char *chemin_fichier )
{
FILE *fichier ;
int ecriture = 0 ;

Cellule<T> *courant = *_debut ;
fichier = fopen( chemin_fichier, "wb" ) ;
if ( fichier == NULL )
{
printf( "Erreur sur ouverture en ecriture du fichier binaire : %s", chemin_fichier ) ;
//exit(-1);
}
else
{
while(courant != NULL)
{
fwrite( courant, sizeof( Cellule<T> ), 1, fichier ) ;
courant = courant->getSuivant() ;
}
ecriture = 1 ;
}
return ecriture ;
}

template <class T>
int Liste<T>::lecture( char * chemin_fichier )
{
FILE *fichier ;
int lecture = 0 ;

int premierMaillon = 0 ;

Cellule<T> *courant ;
Cellule<T> *precedent, *nouveau = NULL ;
//Cellule<T> **leDebut ;

precedent = NULL ;//_debut;
fichier = fopen(chemin_fichier, "rb") ;

if (fichier == NULL)
{
printf("Erreur sur ouverture en lecture du fichier binaire : %s\n", chemin_fichier);
//printf("La reinstallation du programme est necessaire!!!");
//exit(-1);
}
else
{
nouveau = new Cellule<T> ;
while( fread( nouveau, sizeof( Cellule<T>), 1, fichier ) )
{
if ( premierMaillon == 0 )
{
premierMaillon = 1 ;
_debut = &nouveau ;
}
else
{
courant->setSuivant( nouveau ) ;
}
courant = nouveau ;
nouveau->setSuivant( NULL ) ;
nouveau = new Cellule<T> ;
}
lecture = 1;
}
fclose( fichier ) ;
return lecture ;
}

#endif

C'est donc deux classe template. Une qui d�crit une liste chain� et une autre qui l'exploite.
Avec gestion ecriture/lecture des donn�es ds un fichier binaire.
Voil� le souci est celui-ci :

*element = *_debut->getValeur() ;

_debut est un pointeur de pointeur sur un objet Cellule<T> (liste chain�).
element est un pointeur sur un element de tye T (�l�ment de la liste chain�).
pas moyen de corriger l'erreur d'�criture :
error C2227: left of '->getValeur' must point to class/struct/union

[Spir]

*element = (*_debut)->getValeur() ;

tout simplement.