Discussion :

[abdeljaouad]

salut

je suis nouveau dans le monde C++ et j'ai un mini projet à réaliser d'ici 15 juin.

il s'agit d'une application de gestion de comptes bancaires développée sous Visual C++ 6.


les classes qu'il faut définir sont les suivantes :

Personne : titulaire du compte

Compte simple : caractérisé par son titulaire et qu'on peut bien sûr débiter ou créditer d'un certain montant .

Compte courant: pour lequel l'historique des opérations de crédit et de débit sont conservées.il offre la possibilité d'afficher toutes les opérations , les opérations de crédit ou de débit.

pour représenter l'historique , il faudra définir une classe Opération spécialisée en opération de débit et (opération de ) crédit .(il faudra conserver toutes les opérations dans une liste d'opérations chainée encapsulée dans une classe Historique).

NB: pour chaque opération en plus du montant de l'opération d'autres informations peuvent êtres conservées telles que la date de l'opération.

j'ai commencé par implémenter les deux premières classes Personne et Comptesimple , et voilà le code ci dessous :

************ClassPersonne***************

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
class Personne  
{
 
private:
 
	int id;
	char * nom;
	char * adresse;
 
public:
 
	Personne();
	void Print();
	Personne(int,char*,char*);
	Personne& operator=(const Personne&);
	virtual ~Personne();
 
};

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
#include "Personne.h"
#include <string.h>
#include <iostream.h>
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Personne::Personne()
{
	id=0;
	nom=0;
	adresse=0;
 
}
 
Personne::Personne(int x,char * y,char* z)
{
 
	this->id=x;
	this->nom= new char[strlen(y)+1];
	this->adresse= new char[strlen(z)+1];
	this->id++;
 
}
 
Personne::~Personne()
{
 
if (nom) delete nom;
if (adresse) delete adresse;
 
}
 
 
 
Personne& Personne::operator =(const Personne& p)
{
	if(this!=&p)
	{
		if(nom) delete nom;
		if(adresse) delete adresse;
		this->id=p.id;
		this->nom= new char[strlen(p.nom)+1];
		strcpy(nom,p.nom);
		this->adresse= new char[strlen(p.adresse)+1];
		strcpy(adresse,p.adresse);
												}
 
	return (*this);
}
 
 
void Personne::Print()
{
	cout<<"**************Infos Clients**************"<<"\n"<<"\n"<<"\n"<<endl;
	cout<<"ID		:"<<"\t"<<id<<"\n"<<endl;
	cout<<"NOM		:"<<"\t"<<this->nom<<"\n"<<endl;
	cout<<"ADRESSE		:"<<"\t"<<adresse<<"\n"<<endl;
}

***********************CompteSimple*********************

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
class CompteSimple 
{
 
 
private:
 
 
	Personne titulaire;
	int credit;
 
 
public:
 
	CompteSimple();
 
	void print();
	void crediter(int);
	void debiter(int);
 
	CompteSimple(int,char*,char*,int=0);
	virtual ~CompteSimple();
 
 
};

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
#include "ompteSimple.h"
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CompteSimple::CompteSimple()
{
 
}
 
 
CompteSimple::CompteSimple(int a,char* b,char* c,int y):titulaire(a,b,c)
{
 
	y=0;
	this->credit=y;
 
}
 
CompteSimple::~CompteSimple()
{
 
}
 
 
void CompteSimple::debiter(int x)
{
	this->credit=credit-x;
}
 
 
 
void CompteSimple::crediter(int x)
{
 
		this->credit=credit+x;
 
}
 
 
 
 
void CompteSimple::print()
{
	titulaire.Print();
	cout<<"SOLDE		:"<<"\t"<<credit<<"\t"<<"DHS"<<"\n"<<endl;
 
}

j'aimerai avoir vos proposition pour la classe CompteCourant .

Merci

[3DArchi]

Bonjour et bienvenu,
Si ton projet ne te l'interdit pas, utilises les std::string à la place des char* pour manipuler les noms. Cela devrait résoudre le problème suivant :
Essaies ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
int main()
{
   Personne une(0,"nom","adresse");
   { // les accolades sont importantes.
        Personne copie(une);
   }
   return 1;
}

Pour répondre à ta question, tu as déjà fait Personne, tu as déjà fait CompteSimple, que te manque-t-il pour CompteCourant ? (Rappel des règles du forum : Nous ne sommes pas là non plus pour faire vos exercices.)

[abdeljaouad]

je ne sais comment utiliser std::string

en fait pour les deux classes personne et comptesimple y a aucun problème .

pour le comptecourant , l'historique des des opérations doit être conserver.


j'ai pensé à créer une class historique qui composera le comptecourant .

la class historique à son tour doit incorporer plusieurs opérations, donc j'aurais besoin d'une class opération aussi.

mon problème c'est que je ne maitrise pas trop les listes et malheureusement je dois travailler avec dans la classe opération .

ce que je veux c'est juste des idées qui peuvent m'aider à avancer dans le projet et non pas de faire le travail à ma place . ^^ merci

[koala01]

Salut, et bienvenue sur le forum

je ne sais comment utiliser std::string

Ca, c'est le moindre mal...

Pour utiliser la classe std::string, il suffit d'inclure le fichier d'en-tête <string>.

C'est une classe qui fournit l'ensemble des fonctions nécessaires à la gestion de chaines de caractères, et une sécurisation bien supérieur à l'emploi que la solution issue du C qui consiste à gérer des tableaux de caractères terminés par '\0'...

Tu trouvera une réponse à la plupart des questions que tu peux te poser à leur sujet sur la page de la FAQ qui leur est dédiée

en fait pour les deux classes personne et comptesimple y a aucun problème .

C'est déjà pas mal

pour le comptecourant , l'historique des des opérations doit être conserver.
j'ai pensé à créer une class historique qui composera le comptecourant .

Tu semble bien parti

la class historique à son tour doit incorporer plusieurs opérations, donc j'aurais besoin d'une class opération aussi.

En toute logique

mon problème c'est que je ne maitrise pas trop les listes et malheureusement je dois travailler avec dans la classe opération .

Là aussi, le langage C++ peut te venir en aide: il fournit en standard une quantité non négligeable de moyens de gérer des collections d'objets

S'il n'est pas précisé que tu dois tout créer toi même, le conteneur qu'il te faut est std::list, disponible par inclusion du fichier d'en-tête <list>

Généralement, la déclaration d'une liste se fait sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::list<Type_contenu> nom_variable;

n'hésite pas à demander de l'aide sur leur utilisation

Mais tu trouvera déjà quelques infos sur le sujet ici

ce que je veux c'est juste des idées qui peuvent m'aider à avancer dans le projet et non pas de faire le travail à ma place . ^^ merci

Enfin un étudiant sérieux

Je présumes que tu as déjà vu le principe de l'héritage

Hé bien, interroge toi sur un fait particulier:

Peut on décemment dire qu'un compte courant est un compte simple, qui rajoute quelques possibilités qui lui sont propres

Que peux tu déduire de cette réponse

Allez, un peu d'aide là dessus: une discussion assez ancienne sur le principe de substitution de liskov

Un autre conseil que l'on peut te donner, c'est, quoi qu'il arrive, de veiller à déléguer correctement les responsabilités:

Ainsi, si tu ne peux pas utiliser (pour une raison qui ferait que ton prof mérite des coups de pied quelque part) la classe std::list, par exemple, il faut faire la distinction entre

• l'objet contenu dans une collection
• l'élément de la collection
• la collection elle-même

(dans ton cas, l'opération banquaire est l'objet contenu... à toi de voir ce que peuvent être l'élément de la collection et la collection )

J'ai joué à t'aiguiller un maximum... Ce sera tout bénéfice pour toi

Si tu as des questions ou des difficultés, n'hésite pas à venir poser une question plus précise

[abdeljaouad]

salut ,

Merci pour toutes ces explications , c'est vraiment gentil de votre part .

en ce qui concerne le principe d'héritage je l'ai étudié bien évidemment et je me débrouille pas mal avec , même si c'est ma première année en programmation .

d'ailleurs c'est ce que j'ai utilisé pour le compte courant , il hérite du compte simple tout ce qu'il faut et incorpore à son tour un historique propre (à chaque compte) .

j'ai une question à poser :

ça concerne l'enregistrement de la date d'opération (date système).
lors de chaque opération , la date de la réalisation doit être enregistrée avec.
comment pourrais je récupérer celle ci , et sous quel type doit elle être enregistrer (char,char* ..??) ?


Merci koala01

[koala01]

Il existe un fichier d'en-tête nommé <ctime> (le c indiquant qu'il s'agit de la "transcription" d'un fichier d'en-tête issu à l'origine du C )

Il déclare, entre autres choses, une structure de type time_t et une fonction nommée time() qui devraient t'intéresser

Et, comme nous avons essayé de te le faire comprendre, envisage très sérieusement de t'intéresser à la classe string pour éviter les char* au stricte minimum (c'est à dire à quasiment jamais )

Pour répondre à ta question:

• char est un caractère unique
• char* est un pointeur sur un caractère, autrement dit, l'adresse à laquelle nous trouverons un caractère, qui peut, potentiellement, être le premier d'une longue série

Selon toi, que devrais tu utiliser

[abdeljaouad]

la classe string fournit par la biblio stl ou bien un tableau de type char.

je vais essayer de manipuler la class string et je vous tiendrai au courant


merci

[abdeljaouad]

cool la classe string marche a merveille

mnt je me vais me contenter du type time_t et je vous tiendrai au courant

[Mat.M]

je ne sais comment utiliser std::string

c'est ultra simple ; il faut inclure <string> et simplement déclarer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
#include <string>
std::string strChainecharactere="HelloWord";

les classes qu'il faut définir sont les suivantes :

La manière dont tu définis les classes je trouve que c'est un peu mal fait.
Que se passe-t-il si un client a plusieurs comptes ?
Tu devrais définir comme cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
class CCompteCourant{
{
 
};
class CClient{
std::string nom(50);
std::string adresse(50);
std::list<CCompteCourant> liste_ComptesCourants;
std::list<CCompteSimple> liste_ComptesSimples;
 
};

pour représenter l'historique , il faudra définir une classe Opération spécialisée en opération de débit et (opération de ) crédit .(il faudra conserver toutes les opérations dans une liste d'opérations chainée encapsulée dans une classe Historique).

NB: pour chaque opération en plus du montant de l'opération d'autres informations peuvent êtres conservées telles que la date de l'opération.

Il faut obligatoirement enregistrer les opérations dans un SGBD ou une bdd comme MySql, Access,SQL-Server....
Tu peux sérialiser les instances de classes persistantes avec iostream mais c'est une très mauvaise solution tu ne pourras pas faire de requêtes de tri , suppressions etc comme on fait en SQL avec un SGBD

[abdeljaouad]

c'est ultra simple ; il faut inclure <string> et simplement déclarer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
#include <string>
std::string strChainecharactere="HelloWord";

La manière dont tu définis les classes je trouve que c'est un peu mal fait.
Que se passe-t-il si un client a plusieurs comptes ?
Tu devrais définir comme cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
class CCompteCourant{
{
 
};
class CClient{
std::string nom(50);
std::string adresse(50);
std::list<CCompteCourant> liste_ComptesCourants;
std::list<CCompteSimple> liste_ComptesSimples;
 
};

Il faut obligatoirement enregistrer les opérations dans un SGBD ou une bdd comme MySql, Access,SQL-Server....
Tu peux sérialiser les instances de classes persistantes avec iostream mais c'est une très mauvaise solution tu ne pourras pas faire de requêtes de tri , suppressions etc comme on fait en SQL avec un SGBD

le client n'aura qu'un et un seul compte , identifie par ID.

sinon en ce qui concerne enregistrement des operations ca doit se realiser dans une liste<operation> definie dans une class historique voila

merci

[3DArchi]

le client n'aura qu'un et un seul compte , identifie par ID.

sinon en ce qui concerne enregistrement des operations ca doit se realiser dans une liste<operation> definie dans une class historique voila

merci

Tu veux dire une std::list<operation>

[abdeljaouad]

Tu veux dire une std::list<operation>

tout à fait