Partage

Classe template, la valeur fictive est un pointeur d'objet

Comment "avoir l'objet" en lui même?

Sujet résolu

1 octobre 2007 à 13:20:50

Bonjour, je suis en train de m'entraîner à utiliser les classes template.
Actuellement je travail sur une classe TableauPointeurs, qui a pour but de gérer un tableau de pointeur de classe, c'est-à-dire que cette classe contient un attribut membre qui est un tableau contenant des pointeurs de classe.

Les codes:

main.cpp :

#include <iostream>
#include <string>
#include "headers/Tableau_pointeurs.h"
#include "headers/Arme.h"
#include "headers/Armure.h"
using namespace std;
int main()
{
TableauPointeurs<Arme *> arme;
int epee_base = arme.ajouterPointeur (new Arme ());
int hache_de_nain = arme.ajouterPointeur (new Arme ("Hache de nain", 1.5));
int epee_courte = arme.ajouterPointeur (new Arme ("Epee courte", 0.5));
arme.supprimerPointeur (epee_courte);
cout << "# Armes :" << endl;
arme.afficherTableauPointeurs();
TableauPointeurs<Armure *> armure;
int armure_base = armure.ajouterPointeur (new Armure ());
int armure_de_nain = armure.ajouterPointeur (new Armure ("Armure de nain", 2));
int armure_legere = armure.ajouterPointeur (new Armure ("Armure legere", 0.5));
armure.supprimerPointeur (armure_legere);
cout << "# Armures :" << endl;
armure.afficherTableauPointeurs();
TableauPointeurs<Armure *> copie_armure (armure);
copie_armure.afficherTableauPointeurs();
return 0;
}

TableauPointeurs.h :

#ifndef DEF_TABLEAU_POINTEURS
#define DEF_TABLEAU_POINTEURS
#include <iostream>
#include <string>
template <class T>
class TableauPointeurs
{
protected:
T *v_tableau_pointeurs;
int v_nombre_pointeurs;
T* allouerTableauPointeurs (const int nombre_pointeurs) const
{ return new T[nombre_pointeurs]; };
public:
TableauPointeurs();
TableauPointeurs (const TableauPointeurs &tableau_pointeurs);
~TableauPointeurs();
int ajouterPointeur (const T &pointeur);
void supprimerPointeur (const int index);
void viderTableauPointeurs();
void afficherTableauPointeurs();
int getNombrePointeurs() const
{ return v_nombre_pointeurs; };
T getPointeur (const int index) const
{ return v_tableau_pointeurs[index]; };
};
template <class T>
TableauPointeurs<T>::TableauPointeurs()
: v_nombre_pointeurs (0)
{
v_tableau_pointeurs = allouerTableauPointeurs (v_nombre_pointeurs);
}
template <class T>
TableauPointeurs<T>::TableauPointeurs (const TableauPointeurs &tableau_pointeurs)
: v_nombre_pointeurs (tableau_pointeurs.v_nombre_pointeurs)
{
v_tableau_pointeurs = allouerTableauPointeurs (v_nombre_pointeurs);
for (int i = 0; i < v_nombre_pointeurs; ++i)
{
//v_tableau_pointeurs[i] = new Armure (*(tableau_pointeurs.v_tableau_pointeurs[i]));
v_tableau_pointeurs[i] = new T (*(tableau_pointeurs.v_tableau_pointeurs[i]));
}
}
template <class T>
int TableauPointeurs<T>::ajouterPointeur (const T &pointeur)
{
T *temp = allouerTableauPointeurs (v_nombre_pointeurs + 1);
for (int i = 0; i < v_nombre_pointeurs; ++i)
temp[i] = v_tableau_pointeurs[i];
temp[v_nombre_pointeurs] = pointeur;
delete[] v_tableau_pointeurs;
v_tableau_pointeurs = temp;
return (v_nombre_pointeurs++);
}
template <class T>
void TableauPointeurs<T>::supprimerPointeur (const int index)
{
--v_nombre_pointeurs;
T *temp = allouerTableauPointeurs (v_nombre_pointeurs);
int i = 0;
for (int j = 0; j < (v_nombre_pointeurs + 1); ++j)
{
if (j == index)
++j;
if (i < v_nombre_pointeurs)
temp[i] = v_tableau_pointeurs[j];
++i;
}
delete[] v_tableau_pointeurs;
v_tableau_pointeurs = temp;
}
template <class T>
void TableauPointeurs<T>::viderTableauPointeurs()
{
for (int i = 0; i < v_nombre_pointeurs; ++i)
if (v_tableau_pointeurs[i] != NULL)
delete v_tableau_pointeurs[i];
delete[] v_tableau_pointeurs;
v_nombre_pointeurs = 0;
v_tableau_pointeurs = allouerTableauPointeurs (v_nombre_pointeurs);
}
template <class T>
void TableauPointeurs<T>::afficherTableauPointeurs()
{
for (int i = 0; i < v_nombre_pointeurs; ++i)
std::cout << v_tableau_pointeurs[i] << std::endl;
}
template <class T>
TableauPointeurs<T>::~TableauPointeurs()
{
for (int i = 0; i < v_nombre_pointeurs; ++i)
if (v_tableau_pointeurs[i] != NULL)
delete v_tableau_pointeurs[i];
delete[] v_tableau_pointeurs;
}
//#include "../Tableau_pointeurs.tpp"
#endif

Le problème :

Le problème se situe dans le constructeur de copie.
Plus précisément à la ligne 49:

v_tableau_pointeurs[i] = new T (*(tableau_pointeurs.v_tableau_pointeurs[i]));

L'erreur est donc une erreur de conversion:

Citation : Erreur du compilateur :

main.cpp:32: instantiated from here
headers/Tableau_pointeurs.h:49: error: cannot convert `Armure' to `Armure*' in initialization

Normal me direz-vous, puisque la valeur fictive T a dans ce cas la valeur Armure*, ce qui veut dire (si je ne me trompe pas, j'ai tendance à m'embouiller avec les pointeurs) qu'à la ligne 49 (cf.: ci-dessus) je crée un pointeur de pointeur puisque le new crée un pointeur vers Armure* qui est un pointeur.

C'est pour celà que je voudrais savoir s'il est possible de récupérer l'objet de T et non pas un pointeur, j'ai bien essayé un *T mais sans succès j'ai juste le droit à une erreur.

Conclusion :

J'aimerais donc savoir s'il y as un moyen de faire ce que je veux faire ou si je m'y suis mal pris, dans quel cas est-ce que vous pouvez me donner quelques indications sur la méthode à suivre.
Je précise que je ne tiens pas (pour l'instant) à utiliser un objet Vector (je crois que c'est comme ça que sa s'appel) car mon but est d'apprendre à me servir des classes template.

Merci et au revoir.

MatteX

1 octobre 2007 à 17:15:12

Pourquoi veux-tu copier la valeur de l'objet? Ce n'est pas un tableau de pointeurs? logiquement tu n'as qu'à copier la valeur du pointeur...

Parcontre je verrais bien une méthode clone() qui permettrait de créer un tableau de pointeurs avec une copie de chaque éléments : dans ce cas :

1) il te faut un constructeur par copie dans ta classe élément (ici c'est Armure)
2) tu dois essayer de caster tes valeurs et tester le cast_exception ( utilise un static_cast<T>( *tab[ i ] ) ) dans un try-catch
3) en cas d'exception tu détruit le nouveau tableau et tu relance l'exception
4) si tout va bien tu retourne le nouveau tableau
5) À l'appel tu le met aussi dans un try-catch, si tu reçois l'exception c'est que le tableau n'est pas valide.
6) l'appel ce fait ainsi :

pNouvTableau = ancienTableau.clone();

La différence? C'est dans la définition de ce que fait la classe : un tableau de pointeur contient des pointeurs! Lorsqu'il se copie il copie ses éléments soit les pointeurs. Dans certains cas on veut une copie des valeurs pointée, c'est là qu'intervient la méthode clone().

the angel

1 octobre 2007 à 18:24:23

Merci.

En fait ta méthode clone va faire éxactement ce que je veux que fasse mon constructeur de copie.
En fait je ne veux pas copier la valeur du pointeur, car sinon mais deux tableaux pointeraient vers le même objets, or je veux qu'ils puissent agir indépendament.
De manière plus concrète j'utilise cette classe pour gérer l'inventaire de personnages, donc quand je créer un personnage à partir d'un autre je veux aussi créer un nouvel inventaire, de nouvelles armes et armures et non pas utiliser les mêmes, car sinon lorsque je vais changer le contenu de l'inventaire d'un des deux personnages le contenu de l'autre va changer aussi.
En plus j'aurais une erreur à la destruction des objets car le premier va être détruit et les objets vers lesquels il pointe aussi lorsque le deuxième va être détruit il va vouloir détruire des objets qui n'éxistent plus, donc bug.

Pour ce qui est de ta proposition de la méthode clone (qui serait mon constructeur de copie), je ne me suis pas encore entraîner (je n'ai fait que lire la théorie) à utiliser les exeptions et je ne préfère pas m'y mettre maintenant de peut de m'embrouiller puisque je ne suis pas encore tout à fait au point avec les templates et les tableaux de pointeurs, mais merci quand même pour la proposition.

Donc si quelqu'un connaît une autre manière de faire je suis preneur.

Au revoir.

MatteX

1 octobre 2007 à 18:50:51

Je suis un peu mélangé a vrai dire par ta classe parce que tu ne fais pas d'abstraction entre l'implémentation et l'utilisation...

Moi si j'utilise ta classe comme j'utilise std::vector (i.e. sans connaître le code) quand je vois que la classe se nomme TableauPointeurs je m'attend à devoir créer mon pointeurs à l'extérieur de la classe et le détruire moi-même.

je crois que je vais trouver une méthode ajouter( T* ) et non (const T & ).

Je m'attend à devoir libérer la mémoire que j'ai alloué

Je m'attend à pouvoir envoyé le tableau par copie en pouvant accéder à mes pointeurs que les objets pointés seront modifiés lorsque je reviendrai de la fonction...

Mais tu implémente tout simplement un tableau d'objet et qu'en arrière plan tu utilises les pointeurs pour conserver tes éléments, c'est différent.

En lisant le code je me suis aperçu que tu es toi-même mélanger : dans ta méthode d'ajout tu reçois une référence constante et tu essai de l'ajouter comme une pointeur (Buzzer de mauvaise réponse) Il faut faire un choix, soit que l'utilisateur ajoute un pointeur qui a instancié soit il te passe une copie de l'objet et toi tu instancie un pointeur

Après ce choix tu va devoir ajuster la destruction, est-ce que tu dois supprimer ou non les objets pointés (si c'est une copie oui, sinon ce n'est pas à toi de le faire)

et ainsi de suite avec le clone et/ou le constructeur par copie et/ou l'affection et/ou l'accès aux éléments

En ajout : si le but est d'accéléré le processus en utilisant les pointeurs tu perds ce temps en incrémentant/décrémentant la taille du tableau à chaque fois que tu manipule le tableau.

finalement : fait attention return (i++) != return (++i)

the angel

1 octobre 2007 à 19:41:21

Bon je suis désolé je ne vais pas pouvoir répondre correctement je dois m'en aller je voulais juste te remercier pour ces réponses et t'avertir que je réponderais à tes propositions plus tard.

Je tiens tout de même a dire que je connais la différence entre ++i et i++ (si c'est la même qu'en PHP);

int i = 5;
cout << i++ << endl; //Affiche: 5
cout << i << endl; //Affiche: 6
cout << ++i << endl; //Affiche: 7

Encore merci et je reflechirais à tout celà pour pouvoir répondre de manière complète demain.

Au revoir.

lmghs

2 octobre 2007 à 0:44:45

Pour ce genre de classes, bien réfléchir aux responsabilités. Et les documenter en gras, ou forcer les choses à l'aide de classes utilitaires sioux comme les std::auto_ptr<> qui riment avec sémantique de déplacement (à mettre dans un coin de votre tête pour quand vous aurez compris que les pointeurs ne sont pas vos amis)

Sinon, quel est le véritable intérêt de cloner un personnage ou une arme ?

Si c'est pour un intérêt théorique du genre "je pourrais en avoir besoin" => alors oublier tout de suite : cela ne servira jamais. Enfin si. Une telle perte de temps à un intérêt majeur : comprendre que ce n'est pas parce que l'on peut copier que l'on a besoin de copier. Et que du coup, mieux vaut souvent interdire pour être tranquille.

Autant partir dessuite vers une solution de désérialization qui construira des personnages/armes/... depuis des données stockées dans des fichiers.

the angel

2 octobre 2007 à 6:53:40

Encore une fois: merci pour les explications.
Je vais réfléchir à tout celà dans la journé pour y voir plus clair.

Sinon pour ta question lmghs quand à savoir quel est l'intéret de la copie:
Dans mon cas aucun mais je me disais que à partir du moment où l'on develope une classe il faut qu'elle soit capable de gérer toutes les situations (c'est peut-être un mauvais postulat de départ...).
Du coup j'ai voulus implémenter les constructeurs de copies en me disant "si quelqu'un le fait, il faut que celà fonctionne".

Je vais donc repenser entièrement le fonctionnement et le but de mes classes histoire de mettre les choses à plat.

Au revoir.

lmghs

2 octobre 2007 à 8:34:06

A mes débuts, j'ai fait la même "erreur", et perdu des mois à vouloir définir des opérations de copie qui n'apportaient strictement rien d'utile à mon application. Je ne m'en suis d'ailleurs jamais servi -- de la possibilité de copier des réseau de neurones artificiel.

L'astuce est de réfléchir en termes d'entité ou valeur. Une valeur par définition se copie. Une entité, on a parfois besoin de la dupliquer (par clonage), mais c'est franchement rare.

the angel

2 octobre 2007 à 17:18:14

J'ai suivis vos conseils et repenser ma classe TableauPointeurs.
Résultat elle est maintenant plus sousple, elle s'appel simple Tableau et n'est pas restreinte au pointeur, tout dépend de la valeur du type fictif.

Je met le code comme il est pas très très long comme ça si le coeur vous en dit donner moi les critiques :

#ifndef DEF_TABLEAU
#define DEF_TABLEAU
#include <iostream>
template <class T>
class Tableau
{
protected:
T *v_tableau;
int v_nombre_entrees;
T* creerTableau (int nombre_entrees)
{ return new T[nombre_entrees]; };
public:
Tableau();
int ajouterEntree (T element);
void supprimerEntree (int index);
void viderTableau();
T getEntree (int index)
{ return v_tableau[index]; };
int getNombreEntrees()
{ return v_nombre_entrees; };
~Tableau();
};
template <class T>
Tableau<T>::Tableau()
: v_nombre_entrees (0)
{
v_tableau = creerTableau (0);
}
template <class T>
int Tableau<T>::ajouterEntree (T element)
{
T *tableau_temporaire = creerTableau (v_nombre_entrees + 1);
for (int i = 0; i < v_nombre_entrees; ++i)
tableau_temporaire[i] = v_tableau[i];
tableau_temporaire[v_nombre_entrees] = element;
++v_nombre_entrees;
delete[] v_tableau;
v_tableau = creerTableau (v_nombre_entrees);
v_tableau = tableau_temporaire;
//delete[] tableau_temporaire;
return (v_nombre_entrees - 1);
}
template <class T>
void Tableau<T>::supprimerEntree (int index)
{
T *tableau_temporaire = creerTableau (--v_nombre_entrees);
int i = 0;
for (int j = 0; j < (v_nombre_entrees + 1); ++j)
{
if (j == index)
++j;
if (i < v_nombre_entrees)
tableau_temporaire[i] = v_tableau[j];
delete[] v_tableau;
v_tableau = creerTableau (v_nombre_entrees);
v_tableau = tableau_temporaire;
//delete[] tableau_temporaire;
}
}
template <class T>
void Tableau<T>::viderTableau()
{
delete[] v_tableau;
v_tableau = creerTableau (0);
v_nombre_entrees = 0;
}
template <class T>
Tableau<T>::~Tableau()
{
delete[] v_tableau;
}
//#include "../Tableau.ttp"
#endif

Encore une fois merci pour les conseils et puis je vais commencer à regarder du côté de la classe Vector et des "classes utilitaires sioux".
Il est préférable de commencer par quel bout?

Au revoir.

[EDIT]
J'allais oublier, si vous regardez ligne 51 et 73 il y as en commentaire delete[] tableau_temporaire.
Je l'ai enlevé, car sinon le debuger de C::B m'ouvrait une fenêtre avec pour titrer "Back-Trace" mais je comprend pas très bien pourquoi c'est une erreur, car j'ai créé un tableau de manière dynamique dans ma classe, je dois donc le détruire non ?

Du coup j'ai remplacer l'assignation des tableaux par:

delete[] v_tableau;
v_tableau = creerTableau (v_nombre_entrees);
//v_tableau = tableau_temporaire;
copierTableau (tableau_temporaire);
//delete[] tableau_temporaire;

Voic la définition de la fonction copierTableau:

template <class T>
void Tableau<T>::copierTableau (T *tableau)
{
for (int i = 0; i < v_nombre_entrees; ++i)
v_tableau[i] = tableau[i];
}

Je trouve celà plus propre mais est-ce une bonne chose?

lmghs

2 octobre 2007 à 23:21:57

OK. Alors en vrac des remarques.

a- Ce genre de classe se dérive extrèmement difficilement. Syntaxiquement, on arrive à des trucs, mais il y a toujours des pièges au tournant.
=> c'est se mentir que d'utiliser la portée "protégé". "private" est plus juste.

b- pas de <iostream> dans un .h où tu n'utilises ni std::cin, ni std::cout, ni std::cerr, ni std::clog. Si tu as besoin d'une déclaration de std::ostream et/ou std::istream, alors inclus <iosfwd>. Si tu as besoin de la définition de std::istream et/ou std::ostream, alors inclus <istream> et/ou <ostream>.

c- Tes deux accesseurs devraient être "const" car ils ne modifient pas l'état de ton tableau.
De plus, si tu veux pouvoir modifier le i-ème élément, tu va devoir renvoyer une référence sur ce dernier.

Et si tu ne veux pas payer trop cher tes copies pour des gros objects, renvoie un "T const&".
Pour des int, cela pourrait couter plus cher, heureusement l'ininling devrait dégager tout coût ; sans compter que renvoyer une référence constante permet d'exploiter les algos standard (cf le tuto de r0d sur developpez pour ces derniers ; et aussi p.ex. les classiques std::copy(&v[0], &v[N], ....) qui marchent aussi sur des vecteurs non modifiables grâce au type retourné par l'opérateur [] de std::vector<>)

d- Très bien d'utiliser un temporaire avant d'utiliser une copie.

e- ton ajoute() coûte excessivement cher vu que tu réalloues à chaque nouvel élément. std::vector a une croissance logarithmique (si mes souvenirs sont bons) : i.e. cette classe distingue "capacité" et "nombre d'éléments" courants, et réalloue en gros le double de la capacité courante à chaque fois que l'on se sent à l'étroit.

f- Il ne faut JAMAIS modifier un index à l'intérieur d'une boucle, et dans le bloc d'itération d'un for si tu veux arriver à quelque chose.
Au choix,
- fais deux boucles
- distingue capacité et taille, et alors fait partir ton j de "index" directement (ou utilise l'algo de la SL de déplacement qui va bien)

g- A ne pas expliciter (interdire ou spécialiser pour ton cas) les deux opérations de copie, tu vas te rendre dans le mur. cf le tuto de m@téo sur la gestion de d'attributs de type ressource (et la FAQ de developpez (ou quelques archives sur fclc++, developpez, et ici) pour l'opérateur d'affectation)

PS: très bien pour un exo, mais dans du vrai code, utilises std::vector<>.

the angel

3 octobre 2007 à 20:48:07

Alors je reprends:

a - Okk pour la portée private je vais prendre l'habitude de l'utiliser si mes classes ne sont pas héritées.

b - Je prends note, en faite je croyais qu'il était necessaire pour utiliser les template, j'aurais dû tester. Pour le std::ostream et std::istream je retiens.

c - Oups j'ai oublié de les rajouter...
Pour la référence je n'y avais pas penser, mais utiliser une référence sur un pointeur ce n'est pas inutil ? Pour moi la référence sert soit à remplacer les pointeurs, pour plus de facilité, ou à éviter la copie lors du passage en paramètre.
Pour le retour d'une constante, je ne suis pas d'accord, car si je stock un pointeur d'objet et que je désir modifier cet objet, je vais appeler mon accesseur pour qu'il me renvoi le pointeur de l'objet et l'utiliser pour appeler une méthode de l'objet qui va se charger de modifier l'objet, donc si c'est une constante que je revois avec mon accesseur je vais avoir le droit à une erreur non ?

d - Je te remercie mais je ne vois pas trop comment faire autrement...

e - Il est donc plus avantageux d'avoir un tableau avec un surplus de mémoire réservé vis à vis du coût de la réallocation?

f - Oui j'avais aussi penser à faire deux boucles mais je sais plus pourquoi j'ai fait "ça" (en PHP c'est pas bien non plus de passer une valeur calculée comme condition de boucle).

g - Qu'appel tu les deux opérations de copies ? Le constructeur de copie et la surcharge de l'opérateur d'affectation ? Si oui comme je n'en ai pas utilité et que je ne le dévellope lus pour les gens qui aurait l'idée de la faire c'est pas un problème et pour ce qui est de la surcharge des opérateurs je préfère utiliser des fonctions pour plus de lisibilité (mais c'est peut-être un coût top important ?).

Oui, on m'as déjà dit d'utiliser le std::vector, mais là en effet c'est pour m'entraîner.

Merci.

lmghs

4 octobre 2007 à 0:27:07

c- surcharge. version const + version non-const
Quand à l'intérêt, c'est de pouvoir offrir une vue "tableau d'éléments", soit une plage de données itérables, donc un truc utilisable avec les algos standard (et autres).
Pour les signatures, regarde les opérateurs [] de std::vector.

d- "Autrement" ? C'est la mauvaise méthode que 95% (99%?) des gens utilisent par défaut : détruire avant d'allouer.
Après, il y a d'autres façons un chouilla plus sioux qui passent par des objets temporaires de ton type, et par des swap. Approche typique pour définir l'opérateur d'affectation.

e- Définitivement

g- Oui, eux.
Et contrairement à ce que tu penses, tu peux en avoir besoin à tout moment à ton insu (i.e., au premier retour par valeur, au premier stockage dans un autre tableau, ...). Si tu penses sincèrement n'en avoir jamais besoin, alors interdis les (déclarées privées, sans définition). Et tu risques alors d'être surpris de t'en servir là où tu n'y avais pas pensé.
Ce n'est pas une question de coût, mais de sécurité.

the angel

4 octobre 2007 à 18:43:08

Bon alors je vais m'appliquer à faire les modifs.

Mais sinon je vais encore t'embêter un peut au sujet du c.
En fait il faut que je fasse une accesseur const et l'autre identique mais sans le const ?
Pour ce qui concerne les opérteurs [] j'ai fait une rechercher mais je n'ai rien trouvé (je suis malheureusement très peut doué pour ça), j'ai bien trouvé un tuto sur developer.com pour apprendre à utiliser std::vector mais la seule fois où il parles des opérateurs [] c'est pour dire qu'il faut faire attention car ils ne vérifient pas si l'index fournis est valide.
Donc si tu as un lien ou un truc dans le genre je suis preneur.

Merci et au revoir.

[EDIT]
Alors voilà après les modifications :

#ifndef DEF_TABLEAU
#define DEF_TABLEAU
#define CAPACITE_SUPPLEMENTAIRE 20
#define CAPACITE_CRITIQUE 2
#define CAPACITE_AJOUTEE (CAPACITE_SUPPLEMENTAIRE - CAPACITE_CRITIQUE)
template <class T>
class Tableau
{
private:
T *v_tableau;
int v_capacite;
int v_taille;
T* creerTableau (int capacite) const
{ return new T[capacite]; };
T* reserverMemoire() const
{ return creerTableau (v_capacite + CAPACITE_SUPPLEMENTAIRE); };
void copierTableau (T *tableau_temporaire);
public:
Tableau();
Tableau (const Tableau<T> &tableau_temporaire);
int ajouterEntree (T &element);
void supprimerEntree (int index);
void viderTableau();
Tableau<T> operator = (const Tableau<T> tableau_temporaire);
T &getEntree (int index) const
{ return v_tableau[index]; };
int getTaille() const
{ return v_taille; };
~Tableau();
};
template <class T>
Tableau<T>::Tableau()
: v_capacite (CAPACITE_SUPPLEMENTAIRE)
, v_taille (0)
{
v_tableau = creerTableau (CAPACITE_SUPPLEMENTAIRE);
}
template <class T>
Tableau<T>::Tableau (const Tableau<T> &tableau_temporaire)
: v_capacite (tableau_temporaire.v_capacite)
, v_taille (tableau_temporaire.v_taille)
{
std::cout << "constructeur de copie" << std::endl;
v_tableau = creerTableau (v_capacite);
copierTableau (tableau_temporaire.v_tableau);
}
template <class T>
int Tableau<T>::ajouterEntree (T &element)
{
if ((v_capacite - v_taille) < 2)
v_capacite += CAPACITE_AJOUTEE;
T *tableau_temporaire = creerTableau (v_capacite);
for (int i = 0; i < v_taille; i++)
tableau_temporaire[i] = v_tableau[i];
tableau_temporaire[v_taille] = element;
v_taille++;
delete[] v_tableau;
v_tableau = creerTableau (v_capacite);
copierTableau (tableau_temporaire);
delete[] tableau_temporaire;
return (v_taille - 1);
}
template <class T>
void Tableau<T>::supprimerEntree (int index)
{
T *tableau_temporaire = creerTableau (v_capacite);
for (int i = 0; i < index; i++)
tableau_temporaire[i] = v_tableau[i];
for (int i = index; i < v_taille; i++)
tableau_temporaire[i] = v_tableau[i + 1];
v_taille--;
delete[] v_tableau;
v_tableau = creerTableau (v_capacite);
copierTableau (tableau_temporaire);
delete[] tableau_temporaire;
}
template <class T>
void Tableau<T>::viderTableau()
{
delete[] v_tableau;
v_tableau = creerTableau (CAPACITE_SUPPLEMENTAIRE);
v_capacite = CAPACITE_SUPPLEMENTAIRE;
v_taille = 0;
}
template <class T>
void Tableau<T>::copierTableau (T *tableau_temporaire)
{
for (int i = 0; i < v_taille; ++i)
v_tableau[i] = tableau_temporaire[i];
}
template <class T>
Tableau<T> Tableau<T>::operator = (const Tableau<T> tableau_temporaire)
{
std::cout << "surcharge operateur =" << std::endl;
v_capacite = tableau_temporaire.v_capacite;
v_taille = tableau_temporaire.v_taille;
v_tableau = creerTableau (v_capacite);
copierTableau (tableau_temporaire.v_tableau);
return *this;
}
template <class T>
Tableau<T>::~Tableau()
{
delete[] v_tableau;
}
//#include "../Tableau.ttp"
#endif

Je sais que les couts ne devraient pas être là mais comme vous vous en doutez c'était pour savoir si c'était le constructeur de copie ou la surcharge de l'opérateur d'affectation qui était appelé.
En l'occurence tout fonctionne mais il y as une petite bizarerie, ou sinon c'est tout à fait normal mais non précisé dans le tutos de mateo (ni dans mon livre, mais il faut dire que c'est un liver d'initiation lui aussi).
Alors voilà ce que j'ai d'affiché tout en haut de ma console lorsque je fait çà :

Tableau<Arme*> copie_arme;
copie_arme = arme;

Citation : Affichage dans la console

constructeur de copie
surcharge operateur =
constructeur de copie

C'est grave docteur?

lmghs

5 octobre 2007 à 2:26:39

http://dinkumware.com/manuals/default.aspx?manual=compleat&page=vector.html#vector::operator[]

Sinon, pour l'affectation, ne renvoie pas de copie, ne prend pas de copie. (Tu dois pouvoir chercher "swap" dans ce forum, il n'y a pas grand monde sorti de moi à en avoir parlé). Tu trouveras une des écritures canonique de l'opérateur d'affectation.

Tu me parais avoir plus de delete[] que nécessaire.
N'hésite pas à faire des fonctions non plus. Typiquement, le ajouterElement() s'écrit:

void ajouterElement(T const& v) {
if (this->taille() == this->capacite())
this->agrandirCapacite();
this->m_buffer[this->taille()] = v;
++this->m_taille;
// NB: invariant de classe: taille() <= capacite()
// this-> obligatoire avec les templates
}
void agrandirCapacite() { // écrit à la va-vite ; optimisable
Tableau tmp(2*this->capacite() + K);
std::copy( // <- #include<algorithm> ; memcpy() ne marchera pas
this->getEntree(0), this->getEntree(this->taille()),
tmp.getEntree(0));
tmp->m_taille = this->taille();
this->swap(tmp);
// Nécessaire que getEntree() renvoie une référence, ou alors
// attaquer directement m_buffer
// NB: delete[] implicite dans le destructeur de tmp qui contient
// l'ancien tableau au moment de sa destruction
}

PS: dans les toutes premières pages du forum, on avait parlé de ces problèmes avec Cyprien_. Cela concernait l'implémentaion d'une classe chaine, mais au fond, il s'agit à 98% de résoudre les mêmes problèmes.

the angel

5 octobre 2007 à 8:02:49

Merci, je regarderais le lien et le swap.

Pour le pointeur this, je ne saivais pas. J'ai vus dans le stl_vector.h qu'il y était tout le temps et je me demandais pourquoi, maintenant je sais.

Je mais ce sujet comme résolu, car j pense en avoir finis avec les bases des templates. Mon but n'étant pas d'en connaître tout les méandres, le reste viendras avec les cours et l'expérience.

Au revoir.

lmghs

5 octobre 2007 à 9:14:30

Mais ... pratiquement aucune de mes remarques ne touchait les templates.