pourquoi on passe dans telle et telle fonction de ce programme ?

**beegees** · 10/03/2008, 10h22

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

**Médinoc** · 10/03/2008, 11h53

Ta fonction appelle CTabCommunes::Ajouter(const char*)
CTabCommunes::Ajouter(const char*) construit un objet de type CCommune à partir du const char*, et doit donc appeler le constructeur de CCommune prenant un const char* en paramètre.
CCommune::CCommune(const char*) appelle implicitement le constructeur par défaut de CTabReleves, car la classe CCommune contient une variable membre de ce type.
CCommune::CCommune(const char*) appelle implicitement le constructeur par défaut de CChaine, car la classe CCommune contient une variable membre de ce type.
CCommune::CCommune(const char*) appelle CCommune:efinirNom(const char*)
CCommune:efinirNom(const char*) appelle CChaine::Chaine(const char*), qui retourne un bool.
CCommune:efinirNom(const char*) retourne le bool retourné par CChaine::Chaine(const char*)

**beegees** · 10/03/2008, 12h37

Envoyé par Médinoc

Ta fonction appelle CTabCommunes::Ajouter(const char*)
CTabCommunes::Ajouter(const char*) construit un objet de type CCommune à partir du const char*, et doit donc appeler le constructeur de CCommune prenant un const char* en paramètre.
CCommune::CCommune(const char*) appelle implicitement le constructeur par défaut de CTabReleves, car la classe CCommune contient une variable membre de ce type.
CCommune::CCommune(const char*) appelle implicitement le constructeur par défaut de CChaine, car la classe CCommune contient une variable membre de ce type.
CCommune::CCommune(const char*) appelle CCommune:efinirNom(const char*)
CCommune:efinirNom(const char*) appelle CChaine::Chaine(const char*), qui retourne un bool.
CCommune:efinirNom(const char*) retourne le bool retourné par CChaine::Chaine(const char*)

Salut Médinoc,

Un super grand merci pour ton aide et pour ton dévouement.

S'est vraiemnt super sympa, je vais pouvoir analyser ta répone en détail et pouvoir adapter mon code actuel à mon nouveau programme.

Encore un grand merci à toi.

beegees

pourquoi on passe dans telle et telle fonction de ce programme ?

C++

Vue hybride

Discussions similaires

Partager

Partager