Bonjour tout le monde,

J'ai commencé le C++ il y'a 3 semaines et un premier exercice a été fait en classe.

Le problème est que j'ai beaucoup de mal à comprendre certaines choses.

En voici une d'entres elles :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
if (strcmp(Champs[0],"C") == 0)
  {
     --> CommuneCorrecte = Ajouter(Champs[1]);
J'arrive ici :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
bool CTabCommunes::Ajouter(const char* UnNom)
{
	--> return Ajouter(CCommune(UnNom)); 
}
Ajouter(CCommune(UnNom)) : on appelle un constructeur et ensuite une fonction Ajouter ?

Si je fais F11 sur la flèche ci-dessus, je tombe ici je ne comprends pas pourquoi:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
CCommune::CCommune(const char* UnNom)
{
	--> DefinirNom(UnNom);
}
Pour moi, s'est un constructeur surchargé (?)

En cliquant sur F11 sur la flèche ci-dessus, j'arrive ici :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
CTabReleves::CTabReleves()
:m_Nombre(0),m_Tableau(NULL)
{
}
à nouveau, je ne comprends pas pourquoi on arrive ici.

Et pour finir, on revient ici :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
CCommune::CCommune(const char* UnNom)
{
	DefinirNom(UnNom);
}
puis ici :


Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
CChaine::CChaine()
:m_Chaine(NULL)
{
}
puis ici :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
CCommune::CCommune(const char* UnNom)
{
	DefinirNom(UnNom);
}
Ensuite on arrive dans la définition du nom de commune :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
bool CCommune::DefinirNom(const char* UnNom)
{
	if ( (UnNom == NULL) || (strlen(UnNom) < 1) ) return false;
	return m_Nom.Chaine(UnNom);
}
puis ici :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
 
bool CChaine::Chaine(const char* UneChaine)
{
	if (UneChaine == NULL) return false;
	void* Nouveau = realloc(m_Chaine,(strlen(UneChaine)+1)*sizeof(char));
	if (Nouveau == NULL) return false;
	m_Chaine = (char*)Nouveau;
	strcpy(m_Chaine,UneChaine);
	return true;
}
Je ne comprends pas bien pourquoi on passe par les constructeurs...

Voici le code de mon fichier .h cela sera sans doute plus claire :

Merci d'avance pour votre aide. beegees

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
87
88
89
90
91
92
93
#ifndef GEO_H
#define GEO_H
 
#include "chaine.h"
 
class CReleve //un relevé
{
public:
	CReleve();																			// Constructeur par défaut
	CReleve(const CReleve& Source);														// Constructeur par copie
	CReleve(const char* UnNomDeZone, short UneAnnee=0, double UneSuperficie=0.0);		// Constructeur spécifique
	~CReleve();																			// Destructeur
 
	bool		DefinirZone(const char* UnNomDeZone);									// Modificateur du membre m_Zone)
	bool		DefinirAnnee(short UneAnnee);											// Modificateur du membre m_Annee)
	bool		DefinirSuperficie(double UneSuperficie);								// Modificateur du membre m_Superficie)
 
	const char*	Zone() const;															// Accesseur du membre m_Zone) (le this pointe sur un objet constant)
	short		Annee() const;															// Accesseur du membre m_Annee) (le this pointe sur un objet constant)
	double		Superficie() const;														// Accesseur du membre m_Superficie) (le this pointe sur un objet constant)
 
private:
	CChaine		m_Zone;																	// Membre contenant l'adresse d'une chaîne de caractères allouée dynamiquement et contenant le nom de la zone (chaîne non vide)
	short		m_Annee;																// Membre contenant l'année (comprise entre 1800 et 2008)
	double		m_Superficie;															// Membre contenant la superficie (>=0, en km²)
};
 
class CTabReleves
{
public:
	CTabReleves();																		// Constructeur par défaut
	CTabReleves(const CTabReleves& Source);												// Constructeur par copie
	~CTabReleves();																		// Destructeur
 
	void		Vider();																// Modificateur permettant de supprimer tous les éléments existants
	bool		Ajouter(const char* UnNomDeZone, short UneAnnee, double UneSuperficie);	// Modificateur permettant l'ajout en fin de tableau d'un nouvel élément de type CReleve
	bool		Ajouter(const CReleve& Releve);											// Modificateur permettant l'ajout en fin de tableau d'un nouvel élément de type CReleve
	bool		Supprimer(long Indice);													// Modificateur permettant la suppression d'un élément existant
	void		Trier();																// Modificateur permettant de trier les éléments existants (année de relevé croissante, puis nom de zône croissant)
 
	long		Nombre() const;															// Accesseur du membre m_Nombre
	CReleve&	Element(long Indice) const;												// Accesseur donnant accès à un élément du tableau : c'est à dire la référence d'un objet de type CReleve
	long		Indice(const char* UnNomDeZone, short UneAnnee) const;					// Accesseur permettant de retrouver l'indice d'un élément du tableau en fonction de sa clé d'identification (nom de zône & année de relevé)
 
private:
	long		m_Nombre;																// Membre contenant le nombre d'éléments du tableau
	CReleve**	m_Tableau;																// Membre contenant l'adresse d'un tableau des pointeurs sur les objets CReleve
};
 
class CCommune
{
public:
	CTabReleves	Releves;
 
public:
	CCommune();																			// Constructeur par défaut
	CCommune(const CCommune& Source);													// Constructeur par copie
	CCommune(const char* UnNom);														// Constructeur spécifique
	~CCommune();																		// Destructeur
 
	bool		DefinirNom(const char* UnNom);											// Modificateur du membre m_Nom
 
	const char*	Nom() const;															// Accesseur du membre m_Nom
 
private:
	CChaine		m_Nom;																	// Membre contenant l'adresse d'une chaîne de caractères allouée dynamiquement et contenant le nom de la commune (chaîne non vide)
};
 
class CTabCommunes
{
public:
	CTabCommunes();																		// Constructeur par défaut
	CTabCommunes(const CTabCommunes& Source);											// Constructeur par copie
	~CTabCommunes();																	// Destructeur
 
	bool		Charger(const char* NomFichier);										// Modificateur permettant l'ajout de communes et de relevés par commune dont les données proviennent d'un fichier texte
 
	void		Vider();																// Modificateur permettant de supprimer tous les éléments existants
	bool		Ajouter(const char* UnNom);												// Modificateur permettant l'ajout en fin de tableau d'un nouvel élément de type CCommune
	bool		Ajouter(const CCommune& Modele);										// Modificateur permettant l'ajout en fin de tableau d'un nouvel élément de type CCommune
	bool		Supprimer(long Indice);													// Modificateur permettant la suppression d'un élément existant
	void		Trier();																// Modificateur permettant de trier les éléments existants (sur base du nom croissant)
 
	long		Nombre() const;															// Accesseur du membre m_Nombre
	CCommune&	Element(long Indice) const;												// Accesseur donnant accès à un élément du tableau : c'est à dire la référence d'un objet de type CCommune
	long		Indice(const char* UnNom) const;										// Accesseur permettant de retrouver l'indice d'un élément du tableau en fonction de sa clé d'identification (son nom)
 
private:
	long		m_Nombre;																// Membre contenant le nombre d'éléments du tableau
	CCommune**	m_Tableau;																// Membre contenant l'adresse d'un tableau des pointeurs sur les objets CCommune
};
 
#endif//GEO_H