C++

Gestion de tableaux - Besoin de conseil

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Gestion de tableaux - Besoin de conseil

Sve@r

Bonjour,
je suis en train de me mettre au C++. Il se trouve que je dois gérer un tableau d'objets. J'ai donc créé une classe "cArrayElem" qui s'occupe de la gestion du tableau et une classe "cElem" qui s'occupe de chaque élément.
De plus, pour pouvoir gérer le nb d'élements, j'aurais pu mettre une variable "nb" dans la classe "cArrayElem" mais j'ai préféré mettre une variable statique "nb" dans la classe "cElem"

Donc j'ai fait un essai simple qui fonctionne très bien mais j'aimerais savoir si, conceptuellement, c'est bien pensé.

Voici le source

Code :

#include <stdio.h> // I/O fichiers classiques
#include <stdlib.h> // Standard librairies
#define SZ (5) // Taille des allocations
// Classe pour gérer un tableau d'éléments
class cArrayElem {
public:
cArrayElem(int); // Constructeur tableau
~cArrayElem(void); // Destructeur tableau
class cElem; // Déclaration de la classe fille
cElem **tabElem; // Tableau d'éléments
int i; // Indice de boucle
};
// Classe pour gérer un élément
class cArrayElem::cElem {
public:
cElem(int); // Constructeur élément
~cElem(void); // Destructeur élément
int valeur; // Valeur de l'élément
static int nb; // Nb réel d'éléments
static int sz; // Taille allouée
};
// Création des variables statiques de la classe "cElem"
int cArrayElem::cElem::nb;
int cArrayElem::cElem::sz;
// Constructeur d'un élément
cArrayElem::cElem::cElem(int x)
{
// Affichage de contrôle
printf("Création 0x%x - x=%d, nb=%d, sz=%d\n", this, x, cElem::nb, cElem::sz);
// Nouvel élément => nb d'éléments augmente
nb++;
// On remplit sa valeur
valeur=x * x;
}
// Destructeur d'un élément
cArrayElem::cElem::~cElem(void)
{
// Affichage de contrôle
printf("Suppression 0x%x - nb=%d, sz=%d\n", this, cElem::nb, cElem::sz);
// Destruction d'élément => nb d'éléments diminue
nb--;
}
// Constructeur du tableau des éléments
cArrayElem::cArrayElem(int nb)
{
// Allocation initiale
tabElem=(cElem**)malloc(SZ * sizeof(cElem*));
cElem::sz=SZ;
cElem::nb=0;
// Boucle de remplissage
for (i=0; i < nb; i++)
{
// Si on a atteint la taille allouée
if (cElem::nb == cElem::sz)
{
// On incrémente cette taille
cElem::sz+=SZ;
// On réalloue
tabElem=(cElem**)realloc(tabElem, cElem::sz * sizeof(cElem*));
}
// On crée l'élément
tabElem[i]=new cElem(i);
}
printf("\n" );
}
// Destructeur du tableau des éléments
cArrayElem::~cArrayElem(void)
{
printf("\n" );
// Boucle de destruction
while (cElem::nb)
{
// On supprime l'élément
delete tabElem[cElem::nb - 1];
}
// On supprime le tableau d'éléments
free(tabElem);
}
int main(void)
{
// Création du tableau
cArrayElem Array(12);
// Affichage
printf("Array nb=%d, sz=%d\n", cArrayElem::cElem::nb, cArrayElem::cElem::sz);
for (Array.i=0; Array.i < cArrayElem::cElem::nb; Array.i++)
printf("Array(%d)=%d\n", Array.i, Array.tabElem[Array.i]->valeur);
return(0);
}

Merci de m'avoir lu

Message édité par Sve@r le 07-04-2005 à 11:50:10

Publicité

Lam's

Profil: bas.

Sve@r a écrit :

Donc j'ai fait un essai simple qui fonctionne très bien mais j'aimerais savoir si, conceptuellement, c'est bien pensé.

Bon, conceptuellement (ou plutôt : eu égard aux habitudes qu'on a en C++), c'est mal pensé.
On préfère découpler les choses. Or là, ta classe CElem contient une information qui ne concerne que CArrayElem (la taille max). Et lorsque tu te mettras à utiliser la STL, tu verras que ça a encore plus de sens: le conteneur et le contenant ne se connaissent pas du tout. Ils sont combinés ensemble par généricité (templates).

Mais avant d'aller plus avant, est-ce que tu peux nous expliquer ce que tu essayes de produire pour le moment. Parce qu'il y a beaucoup de choses qui ne sont pas catholiques en C++ (le fait que ça soit toléré ne veut pas dire que ça soit raisonnable) : le malloc, les printf, la classe interne non nécessaire, le #define, etc.

LordHarryPotter

Moi je te conseille le type vector (#include <vector> ) qui est un ciontenaur assez puiissant, il possède notamment les itérateurs qui évite de parcourir toute la liste de ton tableau. Je m'explique :

#include <vector>
using std::vector ;

int main(void)
{

vector<MonType> mon_vect ;

// si tu connais la taille à priori
mon_vect.resize(la_taille);

for (vector<MonType>::iterator it = mon_vect.begin() ; it < mon_vect.end() ; ++it)
{
// it est une sortede pointeur pointant sur le ième élément du vecteur
*it = elt_de_type_montype ;
}

// si tu ne connais pas la taille à priori tu as la méthode
mon_vect.push_back(un_elt) ;

// bref t'as plein de moyens de le faire, à noté aussi le
// type const_iterator qui s'utilise comme le type iterator
// sauf que tu ne doit pas change la valeur ......
}

Sve@r

=> Lam's
J'essaye juste de gérer tranquillement un tableau d'éléments. Donc j'avais pensé créer ma classe qui gère le tableau et la classe de l'élément. Et j'avais pensé aux membres statiques pour gérer le nb d'éléments. surtout que dans les bouquins, c'est expliqué qu'un membre statique n'est plus inclus dans une instance de classe mais gère la classe elle-même ce qui me paraissait une bonne idée.
Apparemment, le "vector" sert à ça

=> Seigneur Harry
Merci de ton exemple. Apparemment, ça a l'air puissant.

Merci pour les infos

Taz

bisounours-codeur

y a pas à dire c'est beau le C.

Et puis Coplien se retourne encore une fois dans sa tombe. Merde il est pas mort.

FORUM HardWare.fr

Programmation

C++

Gestion de tableaux - Besoin de conseil

Sujets relatifs
question sur la gestion des fichiers	[Access\|VB] gestion emploi du temps
[ VB.net ] besoin d'aide pour créer une dll	Besoin d'aide sur un code.
Vb et gestion du 64 bit :S	Validation d'un formulaire avec gestion d'alerte
question sur les tableaux	[J2ME] Besoin d'explication sur les données persistentes
Analyse de tableaux	Choix du formulaire besoin d'aide
Plus de sujets relatifs à : Gestion de tableaux - Besoin de conseil

Page générée en 0.063 secondes