# Prototype de classe



## Anonyme (7 Janvier 2011)

Serait-il possible de un prototype de classe comme on le fait pour les fonctions ? 
Car j'ai la classe "Fraction" qui a un membre de type "VectorObjCalcLigne"
Donc on pense mettre la définition de la classe "VectorObjCalcLigne" avant la def. de la classe "Fraction".
Pour l'instant, ça va. 
Le problème c'est que il y a la fonction "calculer()" de la classe "VectorObjCalcLigne" qui renvoie un type "Fraction" !! :affraid:
Donc voilà : serait-il possible de faire un truc comme ça ?


```
[I][PROTOTYPE DE "Fraction"][/I]

class [B]VectorObjCalcLigne[/B] {
	public :
		[B]Fraction[/B] calculer () const;
   [...]
}

class [B]Fraction[/B] {
	private :
		[B]VectorObjCalcLigne[/B] numerateur;
		[B]VectorObjCalcLigne[/B] denominateur;
   [...]
}
```

Il y a peut être d'autres solutions...

Merci d'avance 
xcode


----------



## ntx (7 Janvier 2011)

1 classe par fichier.

Pour éviter les includes croisés, dans le fichier .h utilise la commande "class" :

```
class VectorObjCalcLigne;
```
à la place d'une directive d'include.

Ne fait les include que dans tes fichiers de sources.

Mais d'une manière générale si tu es confronté à ce cas de figure, pose toi déjà la question sur la pertinence de ton design.


----------



## Anonyme (7 Janvier 2011)

Bon, je te post les fichiers:

*VectorCalcLigne.h*

```
#ifndef VectorCalcLigne_H
#define VectorCalcLigne_H

#include "ObjCalcLigne.h"
#include "FillesObjCalc.h"

class VectorCalcLigne {
	private :
	vector<ObjCalcLigne*> listObjCalcLigne;
	
	public :
	VectorCalcLigne ();
	ObjCalcLigne & operator[](size_t i);
	void push_back (ObjCalcLigne &obj);
	void affichCalcLigne (const char* mot, bool tab) const;
	Fraction & calcul_frac () const;
	double calcul_decimal () const;
	void import_debut (VectorCalcLigne &a_importer);
	void import_fin (VectorCalcLigne &a_importer);
	size_t size () const;
};

#endif
```

*VectorCalcLigne.cpp*

```
#include "VectorCalcLigne.h"

VectorCalcLigne::VectorCalcLigne () {}

size_t VectorCalcLigne::size () const {
	return listObjCalcLigne.size();
}

ObjCalcLigne& VectorCalcLigne::operator[](size_t i) {
	return (ObjCalcLigne&)(*listObjCalcLigne.at(i));
}

void VectorCalcLigne::push_back (ObjCalcLigne &obj) {
	listObjCalcLigne.push_back(&obj);
}

void VectorCalcLigne::affichCalcLigne (const char* mot, bool tab) const {
}

Fraction VectorCalcLigne::calcul_frac () const {
	Fraction frac;
	return frac;
}

double VectorCalcLigne::calcul_decimal () const {
	return 0.0;
}

void VectorCalcLigne::import_debut (VectorCalcLigne &a_importer) {
	vector<ObjCalcLigne*> listObjCalcLigneTmp = listObjCalcLigne;
	listObjCalcLigne.clear();
	for (size_t i = 0; i < a_importer.size(); i++) {
		push_back(a_importer[i]);
	}
	for (size_t i = 0; i < listObjCalcLigneTmp.size(); i++) {
		listObjCalcLigne.push_back(listObjCalcLigneTmp[i]);
	}
}

void VectorCalcLigne::import_fin (VectorCalcLigne &a_importer) {
	for (size_t i = 0; i < a_importer.size(); i++) {
		push_back(a_importer[i]);
	}
}
```

*FillesObjCalc.h*

```
#ifdef FILLES_OBJ_CALC_DEF
#define FILLES_OBJ_CALC_DEF

#include "VectorCalcLigne.h"
#include "ObjCalcLigne.h"

using namespace std;

class Substitutions : public ObjCalcLigne {
	
	//Super classe virtuelle pour toutes les classes ObjCalcLigne qui utilisent la substiution de texte et une valeur
	
	protected :
	string substit;
	double valeur;
	bool activSubstit;
};

class Nombre : public Substitutions {
	public :
	Nombre ();
	Nombre (double nbr);
	Nombre (double nbr, string substitut);
	Nombre (double nbr, const char* substitut);
	virtual string getLigneMilieu () const;
};

class Texte : public ObjCalcLigne {
	private :
	string txt;
	
	public :
	virtual string getLigneMilieu () const;
	Texte ();
	Texte (const char* texte);
	Texte (string texte);
};

class Fraction : public ObjCalcLigne {
	private :
	VectorCalcLigne numerateur;
	VectorCalcLigne denominateur;
	
	public :
	virtual vector<string> getLignesHaut () const;
	virtual vector<string> getLignesBas () const;
	virtual string getLigneMilieu () const;
	Fraction ();
	Fraction (VectorCalcLigne &num, VectorCalcLigne &den);
	Fraction (ObjCalcLigne &num, ObjCalcLigne &den);
};

#endif
```

*FillesObjCalc.cpp*

```
#include "FillesObjCalc.h"

/********************************************** Nombre:: **********************************************/

Nombre::Nombre () {
	valeur = 0.0;
	activSubstit = false;
}
Nombre::Nombre (double nbr) {
	valeur = nbr;
	activSubstit = false;
}
Nombre::Nombre (double nbr, const char* substitut) {
	valeur = nbr;
	substit = substitut;
	activSubstit = true;
}
Nombre::Nombre (double nbr, string substitut) {
	valeur = nbr;
	substit = substitut;
	activSubstit = true;
}
string Nombre::getLigneMilieu () const {
	return double_to_string(valeur);
}

/********************************************** Texte:: ***********************************************/

string Texte::getLigneMilieu () const {
	return txt;
}
Texte::Texte () {}
Texte::Texte (const char* texte) {
	txt = texte;
}
Texte::Texte (string texte) {
	txt = texte;
}

/********************************************* Fraction:: *********************************************/

vector<string> Fraction::getLignesHaut () const {
	
}
vector<string> Fraction::getLignesBas () const {
	
}
string Fraction::getLigneMilieu () const {
	
}

Fraction::Fraction () {}
Fraction::Fraction (VectorCalcLigne &num, VectorCalcLigne &den) {
	numerateur = num;
	denominateur = den;
}
Fraction::Fraction (ObjCalcLigne &num, ObjCalcLigne &den) {
	numerateur.push_back(num);
	denominateur.push_back(den);
}
```

*ObjCalcLigne.h*

```
#ifndef ObjCalcLigne_H
#define ObjCalcLigne_H

#include "main.h"

using namespace std;

class ObjCalcLigne {
	
	/*
	 Super classe virtuelle
	 Pour le polymorphysme : faire des vectors de ObjCalcLigne
	*/
	
	public :
		virtual vector<string> getLignesHaut () const;
		virtual vector<string> getLignesBas () const;
		virtual string getLigneMilieu () const =0;
};

#endif
```

*ObjCalcLigne.cpp*

```
#include "ObjCalcLigne.h"

vector<string> ObjCalcLigne::getLignesHaut () const {
	vector<string> haut;
	return haut;
}
vector<string> ObjCalcLigne::getLignesBas () const {
	vector<string> bas;
	return bas;
}
```

*main.h*

```
#ifndef DEF_MAINH
#define DEF_MAINH

#include <iostream>

using namespace std;

#include "math.h"
#include "stringUtil.h"
#include "prefs.h"
#include "FillesObjCalc.h"
#include "tri.h"

[...]

#endif
```

Oufff... 

Merci d'avance
xcode


----------



## ntx (7 Janvier 2011)

```
#ifndef VectorCalcLigne_H
#define VectorCalcLigne_H

#include "ObjCalcLigne.h"

[COLOR="Green"]class Fraction;[/COLOR]

class VectorCalcLigne {
	private :
	vector<ObjCalcLigne*> listObjCalcLigne;
	
	public :
	VectorCalcLigne ();
	ObjCalcLigne & operator[](size_t i);
	void push_back (ObjCalcLigne &obj);
	void affichCalcLigne (const char* mot, bool tab) const;
	Fraction & calcul_frac () const;
	double calcul_decimal () const;
	void import_debut (VectorCalcLigne &a_importer);
	void import_fin (VectorCalcLigne &a_importer);
	size_t size () const;
};

#endif
```

Choisit une fois pour toute ton style de nommage (tu mélanges les "_" et les majuscules)
Ne pas oublier les const sur tous les paramètres passés en référence qui n'ont pas à être modifiés.
Il est préférables que les fonctions get const retourne une référence constante sur le membre, ça évite des copies inutiles.

Mais surtout : que fait la fonction calcul_frac dans cette classe ?


----------



## Anonyme (8 Janvier 2011)

La fonction "calcul_decimal()" renvoie le résultat du calcul sous forme d'un nombre décimal
La fonction "calcul_frac()" renvoie le même résultat mais sous forme de fraction, pour éviter un perte de précision.
3/10 est une valeur exacte tandis que 3.333333333333333333333333... est une valeur approchée. Un double ne pourras jamais contenir une infinité de "3". C'est aussi une question d'affichage. C'est mieux d'afficher :
3
__
10

que 3.333333333333333333333333333333333333333333333333333333...
Voilà 

PS: je vais essayer le "class Fraction;"

---------- Nouveau message ajouté à 10h47 ---------- Le message précédent a été envoyé à 10h22 ----------

J'ai bien fait les modification mais il subsiste un problème :

```
[...]/FillesObjCalc.h:41: [COLOR="red"]error: field 'numerateur' has incomplete type[/COLOR]
[...]/FillesObjCalc.h:42: [COLOR="Red"]error: field 'denominateur' has incomplete type[/COLOR]
```

Voilà les fichiers en question :

*FillesObjCalc.h*

```
#ifndef FILLES_OBJ_H
#define FILLES_OBJ_H

#include "VectorCalcLigne.h"
#include "ObjCalcLigne.h"

class VectorCalcLigne;

class Substitutions : public ObjCalcLigne {
	
	//Super classe virtuelle pour toutes les classes ObjCalcLigne qui utilisent la substiution de texte et une valeur
	
	protected :
	string substit;
	double valeur;
	bool activSubstit;
};

class Nombre : public Substitutions {
	public :
	Nombre ();
	Nombre (double nbr);
	Nombre (double nbr, string substitut);
	Nombre (double nbr, const char* substitut);
	virtual string getLigneMilieu () const;
};

class Texte : public ObjCalcLigne {
	private :
	string txt;
	
	public :
	virtual string getLigneMilieu () const;
	Texte ();
	Texte (const char* texte);
	Texte (string texte);
};

class Fraction : public ObjCalcLigne {
	private :
	[COLOR="Red"]	VectorCalcLigne numerateur;
	VectorCalcLigne denominateur;[/COLOR]
	
	public :
	virtual vector<string> getLignesHaut () const;
	virtual vector<string> getLignesBas () const;
	virtual string getLigneMilieu () const;
	Fraction ();
	Fraction (VectorCalcLigne &num, VectorCalcLigne &den);
	Fraction (ObjCalcLigne &num, ObjCalcLigne &den);
};

#endif
```

*VectorCalcLigne.h*

```
#ifndef VECTOR_CALC_LIGNE_H
#define VECTOR_CALC_LIGNE_H

#include "ObjCalcLigne.h"
#include "FillesObjCalc.h"

class Fraction;

class VectorCalcLigne {
	private :
	vector<ObjCalcLigne*> listObjCalcLigne;
	
	public :
	VectorCalcLigne ();
	ObjCalcLigne & operator[](size_t i);
	void push_back (ObjCalcLigne &obj);
	void affichCalcLigne (const char* mot, bool tab) const;
	Fraction calculFrac () const;
	double calculDecimal () const;
	void importDebut (VectorCalcLigne &aImporter);
	void importFin (VectorCalcLigne &aImporter);
	size_t size () const;
};

#endif
```

Merci encore de ton aide


----------



## ntx (8 Janvier 2011)

```
[COLOR="Red"]#include "VectorCalcLigne.h"
[/COLOR]#include "ObjCalcLigne.h"

[COLOR="red"]class VectorCalcLigne;
[/COLOR]
```
Il y en a un en trop ...


----------



## Anonyme (8 Janvier 2011)

J'ai donc fait ça :

Début de *FillesObjCalc.h*

```
#ifndef FILLES_OBJ_H
#define FILLES_OBJ_H

#include "ObjCalcLigne.h"

class VectorCalcLigne;

class Substitutions : public ObjCalcLigne {
[I][...][/I]
```

Exactement la même erreur ! :hein:


----------



## ntx (8 Janvier 2011)

Dans FillesObjCalc.cpp, il faut mettre l'include VectorCalcLigne.h qui n'est plus dans le header.


----------



## Anonyme (8 Janvier 2011)

Bon. J'ai tout refait :

*FillesObjCalc.h*

```
#ifndef FILLES_OBJ_H
#define FILLES_OBJ_H

#include "VectorCalcLigne.h"
#include "main.h"

using namespace std;

class ObjCalcLigne {
	
	/*
	 Super classe virtuelle
	 Pour le polymorphysme : faire des vectors de ObjCalcLigne
	 */
	
	public :
	virtual vector<string> getLignesHaut () const;
	virtual vector<string> getLignesBas () const;
	virtual string getLigneMilieu () const =0;
};

class Substitutions : public ObjCalcLigne {
	
	//Super classe virtuelle pour toutes les classes ObjCalcLigne qui utilisent la substiution de texte et une valeur
	
	protected :
	string substit;
	double valeur;
	bool activSubstit;
};

class Nombre : public Substitutions {
	public :
	Nombre ();
	Nombre (double nbr);
	Nombre (double nbr, string substitut);
	Nombre (double nbr, const char* substitut);
	virtual string getLigneMilieu () const;
};

class Texte : public ObjCalcLigne {
	private :
	string txt;
	
	public :
	virtual string getLigneMilieu () const;
	Texte ();
	Texte (const char* texte);
	Texte (string texte);
};

class Fraction : public ObjCalcLigne {
	private :
	VectorCalcLigne numerateur;
	VectorCalcLigne denominateur;
	
	public :
	virtual vector<string> getLignesHaut () const;
	virtual vector<string> getLignesBas () const;
	virtual string getLigneMilieu () const;
	Fraction ();
	Fraction (VectorCalcLigne &num, VectorCalcLigne &den);
	Fraction (ObjCalcLigne &num, ObjCalcLigne &den);
};

#endif
```

*FillesObjCalc.cpp*

```
#include "FillesObjCalc.h"

/******************************************* ObjCalcLigne:: *******************************************/

vector<string> ObjCalcLigne::getLignesHaut () const {
	vector<string> haut;
	return haut;
}
vector<string> ObjCalcLigne::getLignesBas () const {
	vector<string> bas;
	return bas;
}

/********************************************** Nombre:: **********************************************/

Nombre::Nombre () {
	valeur = 0.0;
	activSubstit = false;
}
Nombre::Nombre (double nbr) {
	valeur = nbr;
	activSubstit = false;
}
Nombre::Nombre (double nbr, const char* substitut) {
	valeur = nbr;
	substit = substitut;
	activSubstit = true;
}
Nombre::Nombre (double nbr, string substitut) {
	valeur = nbr;
	substit = substitut;
	activSubstit = true;
}
string Nombre::getLigneMilieu () const {
	return double_to_string(valeur);
}

/********************************************** Texte:: ***********************************************/

string Texte::getLigneMilieu () const {
	return txt;
}
Texte::Texte () {}
Texte::Texte (const char* texte) {
	txt = texte;
}
Texte::Texte (string texte) {
	txt = texte;
}

/********************************************* Fraction:: *********************************************/

vector<string> Fraction::getLignesHaut () const {
	vector<string> num;
	//[...] en cours
	return num;
}
vector<string> Fraction::getLignesBas () const {
	vector<string> den;
	//[...] en cours
	return den;
}
string Fraction::getLigneMilieu () const {
	size_t nbrBarresFracs = 2;
	//[...] en cours
	string strMilieu = multipChaine(prefs.BARRE_FRAC, nbrBarresFracs);
	return strMilieu;
}
Fraction::Fraction () {}
Fraction::Fraction (VectorCalcLigne &num, VectorCalcLigne &den) {
	numerateur = num;
	denominateur = den;
}
Fraction::Fraction (ObjCalcLigne &num, ObjCalcLigne &den) {
	numerateur.push_back(num);
	denominateur.push_back(den);
}
```

*VectorCalcLigne.h*

```
#ifndef VECTOR_CALC_LIGNE_H
#define VECTOR_CALC_LIGNE_H

#include "main.h"

class Fraction;
class ObjCalcLigne;

class VectorCalcLigne {
	private :
	vector<ObjCalcLigne*> listObjCalcLigne;
	
	public :
	VectorCalcLigne ();
	ObjCalcLigne & operator[](size_t i);
	void push_back (ObjCalcLigne &obj);
	void affichCalcLigne (const char* mot, bool tab) const;
	Fraction calculFrac () const;
	double calculDecimal () const;
	void importDebut (VectorCalcLigne &aImporter);
	void importFin (VectorCalcLigne &aImporter);
	size_t size () const;
};

#endif
```

*VectorCalcLigne.cpp*

```
#include "VectorCalcLigne.h"

VectorCalcLigne::VectorCalcLigne () {}

size_t VectorCalcLigne::size () const {
	return listObjCalcLigne.size();
}

ObjCalcLigne& VectorCalcLigne::operator[](size_t i) {
	return (ObjCalcLigne&)(*listObjCalcLigne.at(i));
}

void VectorCalcLigne::push_back (ObjCalcLigne &obj) {
	listObjCalcLigne.push_back(&obj);
}

void VectorCalcLigne::affichCalcLigne (const char* mot, bool tab) const {
	//[...] en cours
}

Fraction VectorCalcLigne::calculFrac () const {
	Fraction frac;
	//[...] en cours
	return frac;
}

double VectorCalcLigne::calculDecimal () const {
	//[...] en cours
	return 0.0;
}

void VectorCalcLigne::importDebut (VectorCalcLigne &aImporter) {
	vector<ObjCalcLigne*> listObjCalcLigneTmp = listObjCalcLigne;
	listObjCalcLigne.clear();
	for (size_t i = 0; i < aImporter.size(); i++) {
		push_back(aImporter[i]);
	}
	for (size_t i = 0; i < listObjCalcLigneTmp.size(); i++) {
		listObjCalcLigne.push_back(listObjCalcLigneTmp[i]);
	}
}

void VectorCalcLigne::importFin (VectorCalcLigne &aImporter) {
	for (size_t i = 0; i < aImporter.size(); i++) {
		push_back(aImporter[i]);
	}
}
```


Et les erreurs :
Dans la pièce jointe

Merci d'avance


----------



## Anonyme (8 Janvier 2011)

Ah ok !!!
Je vais regarder ce que ça fait...

---------- Nouveau message ajouté à 11h20 ---------- Le message précédent a été envoyé à 11h19 ----------

Les mêmes erreurs que dans ma pièce jointe...

PS : j'ai pris les fichiers de mon message précédent


----------



## ntx (8 Janvier 2011)

Le problème est dans main.h.


----------



## Anonyme (8 Janvier 2011)

*main.h*

```
#ifndef DEF_MAIN_H
#define DEF_MAIN_H

#include <iostream>

using namespace std;

#include "math.h"
#include "stringUtil.h"
#include "prefs.h"
#include "frac.h"
#include "FillesObjCalc.h"
#include "tri.h"

[...]

#endif
```

Tous les fichiers inclus dans "main.h" incluent "main.h"

---------- Nouveau message ajouté à 12h46 ---------- Le message précédent a été envoyé à 12h00 ----------

Mon projet compile sans le _#include "FillesObjCalc.h"_ de *main.h* ! 
Est-ce que ça pourrait marcher si je met toutes mes classes dans une bibliothèque ?
J'inclurait la bibliothèque dans mon projet qui est déjà gros sans ces classes et ça éviterait de recompiler les classes à chaque fois 

Merci d'avance. 
xcode


----------



## ntx (8 Janvier 2011)

xcode a dit:


> Mon projet compile sans le _#include "FillesObjCalc.h"_ de *main.h* !


Ca m'a l'air d'être un beau bazar tes includes :rateau::rateau::rateau:


> Est-ce que ça pourrait marcher si je met toutes mes classes dans une bibliothèque ?


Oui, mais si tu ne les utilises quand dans ce projet, je n'en vois pas l'utilité. Ne sont recompilés que les fichiers qui ont été modifiés.


----------



## Anonyme (8 Janvier 2011)

Je vais créer un nouveau projet avec juste les fichiers dont j'ai besoin.


----------



## Anonyme (8 Janvier 2011)

Voilà le projet.
Qui ne compile pas :hein:


----------



## ntx (8 Janvier 2011)

Bon, on en découvre tous les jours. La "forward declaration" ne fonctionne que sur des pointeurs ou des références.


----------



## Anonyme (8 Janvier 2011)

Mon projet compile !!!!! Enfin ! 
J'ai tous réunit dans deux fichiers (un .h et un .cpp). Je sais c'est pas bien, mais ça marche ! 
J'ai aussi mis "class Fraction;" devant la classe "VectorCalcLigne"
La fonction "Fraction calculFrac () const" devient "Fraction & calculFrac () const"

Merci beaucoup de ton aide, NXT.


----------



## ntx (8 Janvier 2011)

Encore un détail sur tes constructeurs :

```
Fraction::Fraction ([B]const[/B] VectorCalcLigne &num, [B]const[/B] VectorCalcLigne &den) 
  : 	[B]numerateur(num),
	denominateur(den)[/B]
{
}
```
C'est mieux si bien entendu on n'a pas oublié de définir le constructeur de copie. Les const ne sont pas là que pour faire joli, il faut de la rigueur sur l'aspect constant ou non des variables sous peine de problème dans le cours de ton développement.

Fraction::Fraction (const Fraction &src) 

Et n'hésite pas à mettre dans tes classes un destructeur, virtuel toujours, ça sera mieux que celui défini par défaut par le compilo.


----------



## tatouille (8 Janvier 2011)

pourquoi ecris tu du chmeurk++? en utilisant du c++; (c'est vraiment donner de la confiture aux cochons) language de templating qui peut reduire a  quelques dizaines de lignes ton chmeurk++, ce que tu veux c'est 2 classes:  Template Tor, Template FuncTor.

je te conseille vivement d'acheter ce livre avant d'aller plus loin dans le chmeurk++


*C++ Template Metaprogramming*



http://www.boostpro.com/mplbook/


de plus personne ne fait ca: 
using namespace std;

a part les chmeurkeurs++ ++ ++; qui veulent volontairement se tirer dans les pieds et etre victime de namespace pollution et autres stupiditées.

de plus les membres ... sans parler de l'indentation catastrophique de tes headers et du franc-anglais ... (t'as un style de mer** man! corrige ca tout de suite), un point positif tu sembles etre sensible a l'_Alignment_. 

```
protected:
    std::string    m_subtitle;
    double         m_value; // es-ce vraiment ce que tu veux (64bit type) ou un float reflechis bien ici.
    bool           m_issubtitle;
```


----------



## Anonyme (10 Janvier 2011)

1) J'ai pas le tps de faire des std:: partout
2) J'ai 13 ans, j'ai pas assez de sous pour m'acheter les bouquins
3) Pour les noms, j'ai pas le tps non plus
4) C'est bien des double que je veux. C'est un logiciel de maths !
5) Et oui j'ai un style de merde et je fais du chmeurk++ 
6) Et pas besoin de me dire que je fais pas assez de commentaires
7) Je te rappelle que mon projet et le contenu des classes est en cours; les templates ne seront d'aucunes utilités quand je remplirai les méthodes.

Ntx est un peut plus sympa. Il me gueule pas dessus... :rateau:
Si t'as des choses plus intéressantes à me dire...

xcode


----------



## tatouille (11 Janvier 2011)

au lieu de raler avec des conneries utilise ton culot pour trouver ce bouquin  je suis sur qu'un de tes profs/parents au sens large sera a meme de trouver une solution  demande au lieu de chialier  pour ce qui me concerne ca a toujours ete mon ecole donne des coup pied au cul et t'auras des resultats, note que je ne fais que ca avec des personnes qui a mon sense on quelque chose mais son _empêtrer dans une fainéantise a qui la faute societe poussant a limmaturité, irresponsabilité des parents, a la fin on s'en fou trace ton chemin.
_


----------



## Anonyme (11 Janvier 2011)

Ok, ok, ok...
Je reformule...
1) J'ai jamais eu de problèmes avec les "using namespace"
2) Je me démerderais pour trouver ton bouquin
3) Pour les noms, ça me dérange pas de faire du franglais
4) C'est bien des double que je veux. C'est un logiciel de maths !
5) Et oui j'ai un style de merde et je fais du chmeurk++ (dis moi au moins ce qui est à changer au lieu de me gueuler dessus)
6) Et pas besoin de me dire que je fais pas assez de commentaires, je les ferais à la fin ( je vais pas mourir tout de suite )
7) *Je te rappelle que mon projet et le contenu des classes est en cours; les templates ne seront d'aucunes utilités quand je remplirai les méthodes.*
8) Les templates, je les utilises beaucoup (le fichier zip, c'est qu'une minuscule partie de mon projet)
9) Je mettrai des m_ devant les noms des membres
10) Tu pourrais pas faire moins de fautes :rateau:

Rien d'autre ?

Cordialement, xcode


----------

