Programmation d'un Agenda [Erreur dans le code?]

Version imprimable

Bonjour à tous,
j'espère que je ne me suis pas tromper de forum pour vous exposer mon problème.

j'aimerai faire une procedure qui a partir d'un agenda de personne, classe les gens selon leur prefixe téléphonique.
J'ai dont essayer de codé tout ça mais ça ne me les copie pas correctement et je cherche donc l'erreur.
Pouvez vous m'aider ?

http://img714.imageshack.us/img714/2200/sanstitresy.png

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedef struct
{
        char nom[20];
        char prenom[20];
        char tel[10];
        int rang;
}Agenda;
 
typedef struct
{
        char nom[20];
        char prenom[20];
        char tel[10];
        int rang;
}PrefixeTel01;

Code:

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
 //procedure classé par region
         void region(Agenda TabPers[Maxtaille],int Nbpers,PrefixeTel01 *Tab01,PrefixeTel02 *Tab02,PrefixeTel03 *Tab03,PrefixeTel04 *Tab04,int *Nb01,int *Nb02,int *Nb03,int *Nb04 )
{
 
         int i,j,k,l,m;
         bool Trouve01,Trouve02,Trouve03,Trouve04;
 
// initalisation des variables
j=0;
k=0;
l=0;
m=0;
Nb03=0;
Nb01=0;
Nb02=0;
Nb04=0;
 
 
for(i=0;i<Nbpers;i++) //Debut de la boucle qui parcours l'agenda
{
Trouve01=false;
Trouve03=false;
Trouve03=false;
Trouve04=false;
 
string compare=TabPers[i].tel; //compare reçois le numero de tel d'une personne de l'agenda
 
if (compare.substr(0, 1)=="01"); //Compare si les 2 premiers numero sont 01 
{
strcpy (Tab01[j].nom,TabPers[i].nom);
strcpy (Tab01[j].prenom,TabPers[i].prenom); //copie les info de la personne dans le tableau departemental 01
strcpy (Tab01[j].tel,TabPers[i].tel);
 
j++;
Trouve01=true;
}
 
if (compare.substr(0, 1)=="02");//Compare si les 2 premiers numero sont 02
{
strcpy (Tab02[k].nom,TabPers[i].nom);
strcpy (Tab02[k].prenom,TabPers[i].prenom); //copie les info de la personne dans le tableau departemental 02
strcpy (Tab02[k].tel,TabPers[i].tel);
 
k++;
Trouve02=true;
}
 
if (compare.substr(0, 1)=="03");//Compare si les 2 premiers numero sont 03
{
strcpy (Tab03[l].nom,TabPers[i].nom);
strcpy (Tab03[l].prenom,TabPers[i].prenom); //copie les info de la personne dans le tableau departemental 03
strcpy (Tab03[l].tel,TabPers[i].tel);
 
l++;
Trouve03=true;
}
 
if (compare.substr(0, 1)=="04");//Compare si les 2 premiers numero sont 04
{
strcpy (Tab04[m].nom,TabPers[i].nom);
strcpy (Tab04[m].prenom,TabPers[i].prenom); //copie les info de la personne dans le tableau departemental 04
strcpy (Tab04[m].tel,TabPers[i].tel);
 
m++;
Trouve04=true;
}
 
if (Trouve01=true)
{               //compte toutes les personnes qui sont ds le departement01
Nb01=Nb01+1;
}
 
if (Trouve02=true)
{               //compte toutes les personnes qui sont ds le departement02
Nb02=Nb02+1;
}
 
if (Trouve03=true)
{               //compte toutes les personnes qui sont ds le departement03
Nb03=Nb03+1;
}
 
if (Trouve04=true)
{              //compte toutes les personnes qui sont ds le departement04
Nb04=Nb04+1;
}
 
}
}

Bonjour et bienvenu,
La fonction substr est :

Code:

std::string::substr ( size_t pos = 0, size_t n = npos ) const;

Le premier paramètre est bien une position mais le second est la taille de la sous chaîne et non la position de fin.
Donc, les tests compare.substr(0, 1)=="0X" sont toujours faux, car "0" sera toujours différent de "01", "02", "03, ou "04". Ce serait au mieux compare.substr(0, 2)=="0X".
Ensuite, tu as mis un ';' à la fin de chaque if ce qui fait que si la condition est vraie, aucune instruction n'est exécutée. En effet, ce ';' fait office d'instruction vide et ton bloc n'est par conséquent plus associé à l'instruction if. La bonne syntaxe est :
Code:

1 2 if (compare.substr(0, 2)=="01") // pas de ';' ici. {
Ensuite, je ne garantie pas que tes tableaux dynamiques fonctionnent car tu utilises des pointeurs (gros risque de bug).

Sinon, tout ton code n'est pas C++ et je serais ton prof, j'aurais du mal à accepter un tel code. Voyons quelques uns des problèmes :
-> En C++ il n'est nul besoin d'employer typedef pour définir une structure, une union, un énum ou une classe. Le type est introduit dès sa déclaration :
Code:

1 2 3 4 struct Agenda { // [...] };
-> Je ne comprends pas l'intérêt de la classe PrefixeTel01 ? Pourquoi ne pas utiliser la classe Agenda puisqu'elles semblent toutes deux identiques ?

-> Les chaînes de caractères en C++ sont std::string et pas des tableaux de char :
Code:

1 2 3 4 5 6 7 struct Agenda { std::string nom; std::string prenom; std::string tel; int rang; };
L'utilisation des std::string t'éviteras les nombreux strcpy puisqu'une simple affectation suffit :
Code:

1 2 3 std::string s1("coucou"); std::string s2; s2 = s1; // s2=="coucou"
D'autant plus que strcpy est source d'erreurs si les chaines sont mal construites, on des problèmes de tailles, d'absence de \0, etc. (et strcpy est une faille de sécurité il me semble).

-> L'utilisation des Nb01, Nb02 etc est incorrecte. Tu passes par pointeur certainement pour mettre à jour la valeur. Sauf que tu ne mets pas à jour cette valeur mais tu change le pointeur. Tu devrais écrire :
Code:

1 2 3 *Nb01=0; // puis, plus loin : *Nb01 = (*Nb01)+1;
Note qu'un passage par référence t'aurais évité ce genre d'erreur :
Code:

1 2 3 4 void region(Agenda TabPers[Maxtaille],int Nbpers,PrefixeTel01 *Tab01,PrefixeTel02 *Tab02,PrefixeTel03 *Tab03,PrefixeTel04 *Tab04,int &Nb01,int &Nb02,int &Nb03,int &Nb04 ) { Nb01 = 0; }
-> Ta fonction me semble diablement compliquée pour ce qu'elle veut faire : j,k,l et m sont redondants avec Nb01, Nb02, Nb03 et Nb04. Et l'utilisation des booléens est inutile :
Code:

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 void region(Agenda TabPers[Maxtaille],int Nbpers,Agenda *Tab01,Agenda*Tab02,Agenda*Tab03,Agenda*Tab04,int *Nb01,int *Nb02,int *Nb03,int *Nb04 ) { *Nb03=0; *Nb01=0; *Nb02=0; *Nb04=0; for(int i=0;i<Nbpers;i++) //Debut de la boucle qui parcours l'agenda { std::string const compare=TabPers[i].tel.substr(0,2); //compare reçois le numero de tel d'une personne de l'agenda if (compare=="01") //Compare si les 2 premiers numero sont 01 { Tab01[*Nb01] = TabPers[i]; (*Nb01)++; } if (compare=="02") //Compare si les 2 premiers numero sont 02 { Tab02[*Nb02] = TabPers[i]; (*Nb02)++; } if (compare=="03") //Compare si les 2 premiers numero sont 03 { Tab03[*Nb03] = TabPers[i]; (*Nb03)++; } if (compare=="04") //Compare si les 2 premiers numero sont 04 { Tab04[*Nb04] = TabPers[i]; (*Nb04)++; } } }
ou avec les références :
Code:

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 void region(Agenda TabPers[Maxtaille],int Nbpers,Agenda *Tab01,Agenda*Tab02,Agenda*Tab03,Agenda*Tab04,int &Nb01,int &Nb02,int &Nb03,int &Nb04 ) { Nb01=0; Nb02=0; Nb03=0; Nb04=0; for(int i=0;i<Nbpers;++i) //Debut de la boucle qui parcours l'agenda { std::string const compare=TabPers[i].tel.substr(0,2); //compare reçois le numero de tel d'une personne de l'agenda if (compare=="01") //Compare si les 2 premiers numero sont 01 { Tab01[Nb01] = TabPers[i]; Nb01++; } if (compare=="02") //Compare si les 2 premiers numero sont 02 { Tab02[Nb02] = TabPers[i]; Nb02++; } if (compare=="03") //Compare si les 2 premiers numero sont 03 { Tab03[Nb03] = TabPers[i]; Nb03++; } if (compare=="04") //Compare si les 2 premiers numero sont 04 { Tab04[Nb04] = TabPers[i]; Nb04++; } } }
-> Pour les tableaux dynamiques, l'utilisation de std::vector sécurise et facilite quand même les choses, t'évitant la gestion de la mémoire dynamique et les nombreux paramètres de taille :
Code:

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 void region(std::vector<Agenda> const & TabPers,std::vector<Agenda> &Tab01,std::vector<Agenda> &Tab02,std::vector<Agenda> &Tab03,std::vector<Agenda> &Tab04) { for(std::vector<Agenda>::size_type i=0;i<TabPers.size();i++) //Debut de la boucle qui parcours l'agenda { std::string const compare=TabPers[i].tel.substr(0,2); //compare reçois le numero de tel d'une personne de l'agenda if (compare=="01") //Compare si les 2 premiers numero sont 01 { Tab01.push_back(TabPers[i]); } if (compare=="02") //Compare si les 2 premiers numero sont 02 { Tab02.push_back(TabPers[i]); } if (compare=="03") //Compare si les 2 premiers numero sont 03 { Tab03.push_back(TabPers[i]); } if (compare=="04") //Compare si les 2 premiers numero sont 04 { Tab04.push_back(TabPers[i]); } } }

15/03/2010, 02h47
maxime06
Rebonsoir,

Merci d'avoir répondu aussi rapidement et surtout avec une réponse extrêmement complète.

En effet, j'ai plein d'incohérence dans le code et surtout des variables inutiles qui surcharge mon code.

J'avais mal compris l'utilisation de la fonction substr, surement la raison pour laquelle je retrouvais des numéros de téléphone là où n'étaient pas leurs places.

La classe PréfixeTel01 c'est vrai qu'elle ne sert à rien vu que c'est la même structure que Agenda. J'avais en tete qu'il fallait refaire un enregistrement pour chaque tableau, se qui était faux. Oui en effet maintenant ça parait tellement logique.

Concernant l'utilisation de "std::vector" je ne connaissais pas. Ça a l'air pas mal.

"Char" est un caractère et "string" une chaine de caractère ?

Par contre j'aurai une question dans le code
Code:

1 2 3 std::string s1("coucou"); std::string s2; s2 = s1; // s2=="coucou"
Je ne comprends l'utilisation du "std::" devant.
Cela a t'il un rapport avec using namespace std ?

Ce code es t'il correct ?
Code:

1 2 3 4 using namespace std; string s1("coucou"); string s2; s2 = s1; // s2=="coucou"
Je pense que je devrais trouver l'explication dans les tutos.

Edit: Oui en effet je viens de trouver un tutoriel qui me confirme que cela fonctionne.

Citation:

c'est un référentiel lexical : les fonctions et classes de la bibliothèque standard sont définies dans std

alors soit tu préfixes par std:: soit tu mets la directive using qui introduit std dans le référentiel lexical courant. pour un projet de débutant, c'est ok, mais pour quelque chose de plus gros, ou tu manipules plusieurs namespace, et bien les namespace permettent de résoudre les collisions

-----------
-----------

Sinon encore merci de vous être penché sur mon code pour m'apporter des solutions.

Je vous tiens au courant pour vous dire si les modifications et les explications apportés ont bien résolu mon problème.
16/03/2010, 02h04
maxime06

J'ai intégré ma procédure au reste de mon programme, il s'adapte et fonctionne parfaitement.

Merci de m'avoir corrigé, et donné des explications.