--------------------------------------------------
Subject: [IFT1166] TP2: prg. test.
Date: Wed, 10 Nov 1999 17:24:25 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] a propos
de la compilation avec calculette.cpp (ou .o)
Date: Wed, 10 Nov 1999 11:12:52 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] TP2: code source de
calculette.cpp
Date: Tue, 09 Nov 1999 10:43:19 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] demo#6 & TP2
Date: Thu, 04 Nov 1999 18:54:29 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] Q/R TP2 -7- classe string
Date: Mon, 01 Nov 1999 16:49:26 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] Q/R TP2 -6- remplissage d'un
tableau.
Date: Mon, 01 Nov 1999 16:46:09 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] Questions/Reponses ---TP2---
-5-
Date: Mon, 01 Nov 1999 11:59:27 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] Questions/Reponses
---TP2--- -4-
Date: Sat, 30 Oct 1999 18:09:28 -0400
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] Questions/Reponses
---TP2--- -3-
Date: Fri, 29 Oct 1999 18:31:16 -0400
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] Questions/Reponses
---TP2--- -2-
Date: Thu, 28 Oct 1999 15:16:18 -0400
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Subject: [IFT1166] Questions/Reponses
--- TP2 --- -1-
Date: Mon, 25 Oct 1999 14:53:55 -0400
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
=======================================================================================
Subject: [IFT1166] TP2: prg. test.
Date: Wed, 10 Nov 1999 17:24:25 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
Bonjour,
afin de rendre l'edition des liens independante des criteres de conception
des classes mentionnees dans le tp, j'ai recompile le code source de
partage.cpp (*) ; le code source de calculette.cpp est lui disponible.
Ces programmes ne sont pas vraiment necessaires, vous pouvez fabriquer
vous meme un programme "main" ou utiliser celui deja poste sur cette
liste
pour tester l'ensemble des operations.
la ligne de compilation de l'ensemble des fichiers reste la meme.
Mohamed Lokbani.
(*) recompile uniquement pour Redhat6.0
=======================================================================================
Subject: [IFT1166] a propos de la compilation
avec calculette.cpp (ou .o)
Date: Wed, 10 Nov 1999 11:12:52 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
Bonjour,
beaucoup de personnes sont venus me voir ainsi que votre demonstrateur
(Philippe Langlais)
pour nous dire qu'ils avaient des problemes a linker leurs programmes
avec le programme
calculette.o (+partage.o).
Apres nos tests, il s'est avere que leurs programmes ne compilaient
meme pas, avant meme
d'inclure l'edition de liens avec le programme "calculette.o+partage.o".
Il est tres facile et rapide de verifier cela:
g++ -Wall -c rep.cpp
compile uniquement le fichier rep.cpp et produit en sortie rep.o
g++ -Wall -c grdent.cpp
compile uniquement le fichier grdent.cpp et produit en sortie grdent.o
Si au moins l'une des deux compilations signale au moins une seule erreur
pas besoin
d'aller plus loin! Corrigez votre erreur.
Et le programme de "calculette.o" n'a rien a y avoir avec vos erreurs de compilation.
Donc compilez a part vos fichiers, verifiez qu'il n'y a aucune erreur
ni warning,
puis par la suite faites l'edition de lien avec le programme calculette.o
comme mentionnee
dans l'enonce du tp2.
Mohamed Lokbani.
=======================================================================================
Subject: [IFT1166] TP2: code source
de calculette.cpp
Date: Tue, 09 Nov 1999 10:43:19 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
Bonjour,
pour s'assurer que votre programme correspond bien a ce qu'il a ete
demande
et afin de faciliter le debugage lors de l'edition des liens, ci-joint
le code source
de calculette.cpp
vu que partage.cpp est la, uniquement pour l'interface utilisateur,
je ne la rendrai
pas public (ne vous attardez pa sur la fonction Getoperateur).
Assez souvent les problemes d'editions de liens se produisent a cause du fait:
le nom des fonctions n'est pas le meme entre le programme appelant (main)
et votre
librairie, ou bien la fonction est inexistante.
Mohamed Lokbani.
-------------------------------------------------------------------------------------
#include "partage.h"
int main()
{
GrdEnt accumulateur(0);
// accmule dans cet objet
GrdEnt courant;
// valeur test
Operation op = addition;
// test une addition avec zero, addition vaut zero
const string s = "7437380164651435143865874852299929767";
GrdEnt A(s);
GrdEnt B(2);
int i = 10;
GrdEnt D = A + i;
cout << "D1: " << D << endl;
D = i + A;
cout << "D2: " << D << endl;
cout << "\ntest des grands entiers!\n\n";
cout << "\nA vaut: \n" << A <<
endl;
cout << "\nB vaut: \n" << B <<
endl;
cout << "\nLa somme de A+B est egale a: \n" << (A+B) << "\n\n";
cout << "\nA vous de jouer ..... \n\n\n";
while (op != stop)
{
cout << "\nentrer
une valeur: ";
cin >> courant;
switch (op)
{
case addition:
accumulateur += courant;
break;
case soustraction:
accumulateur -= courant;
break;
case multiplication:
accumulateur *= courant;
break;
default:
cerr << "error, operateur inconnu" << endl;
}
cout << "----> " <<
accumulateur << endl;
cout << endl;
op = GetOperateur();
}
return 0;
}
=======================================================================================
Subject: [IFT1166] demo#6 & TP2
Date: Thu, 04 Nov 1999 18:54:29 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Bonjour,
-1-
j'ai mis la solution de la demo #6 sur la page web du cours @:
http://www.iro.umontreal.ca/~dift1166
a propos des deux operations (vous pouvez generaliser pour les autres operations):
a+=b & c= a+b;
inspirez-vous de l'exercice du 3 de cette demo, pour realiser votre
TP.
-2- une suggestion ....
vous pouvez ajouter des fonctions membres aux deux classes. Par exemple
ds la
classe Representation, vous pouvez avoir aussi une fonction membre
qui remet a
jour la taille de votre digit, si la taille deja etablie devient insuffisante
pour contenir
votre "nouveau" digit (exemple lors d'une addition, multiplication
etc.).
pour se faire vous aurez juste a creer un nouveau tableau, copiez les
anciennes valeurs
detruire l'ancien tableau, repointer le pointeur de l'ancien tableau
vers le nouveau.
c'etait juste une suggestion, si vous avez une meilleure idee, la voie
est libre ....
Mohamed Lokbani.
=======================================================================================
Subject: [IFT1166] Q/R TP2 -7- classe string
Date: Mon, 01 Nov 1999 16:49:26 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Bonjour,
A propos de la classe string. Je ne crois pas que vous aillez besoin de la connaitre de A a Z!
connaitre les commandes decrites dans l'exemple qui suit devrait etre
suffisant! Ceci dit si
vous avez des problemes a manipuler d'autres commandes que vous jugez
necessaires,
vous savez ou nous trouver.
Mohamed Lokbani
------------------------------------------------------
#include <iostream.h>
#include <string>
int main()
{
string c;
c = "livre";
cout << c << endl; // affiche livre
c[0] = 'v'; // le premier element de c i.e. "l" est remplace par "v"
cout << c << endl; // affiche vivre
int m = c.length(); // obtenir la taille de c
cout << m << endl; // affiche 5
}
----------------------------------------------------------------------------------------
=======================================================================================
Subject: [IFT1166] Q/R TP2 -6- remplissage
d'un tableau.
Date: Mon, 01 Nov 1999 16:46:09 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Bonjour,
Un des etudiants est venu me voir avec la meme question a propos de
l'appel:
Representation (int taille, const char & data);
suite a notre discussion, j'ai compris le pourquoi de ce nombre de questions
a propos
de la declaration mentionnee plus haut!
Votre probleme je crois c'est d'avoir conclu hativement que l'appel :
Representation (int taille, const char & data);
servait aussi a remplir votre tableau Digits avec les donnees du GrdEnt.
Or ce n'est pas le cas.
Le remplissage de ce tableau doit se faire au niveau de la classe GrdEnt.
Une suggestion (la voie est libre si vous avez une meilleure idee) comment resoudre cela:
creez une fonction au niveau de la classe GrdEnt, elle aura pour tache
de remplir le
tableau alloue, que ca soit pour
- un entier (suite a l'appel de GrdEnt(int nombre) )
ou
- une chaine de caracteres (suite a l'appel de GrdEnt(const string &))
de cette facon vous n'aurez pas a dupliquer votre code.
Mohamed Lokbani.
=======================================================================================
Subject: [IFT1166] Questions/Reponses ---TP2---
-5-
Date: Mon, 01 Nov 1999 11:59:27 -0500
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Bonjour,
Question 1
-----------
>>>J'aimerais savoir si on a le droit d'utiliser la classe vector du STL?
Non, tu ne peux l'utiliser. Contentes toi de la classe <string> et
de respecter les types
predefinis pour les membres des deux classes: GrdEnt & Representation.
Tu vas etudier la classe <vector> si tout va bien, dans le dernier
cours. Tant que ce
n'est pas fait, tu ne vas pas l'utiliser.
Question 2
-----------
>>>C'est toujours le meme probleme ui me tracace, a propos
>>>de la declaration du 3eme constructeur pour la classe Representation.
>>>Pourquoi l'avoir definie ainsi,
>>>Representation (int taille, const char & data);
>>>au lieu de,
>>>Representation (int taille, const char data[]);
>>>(par rapport a mon dernier courrier, j'ai enleve la reference
>>>parce que c'etait faux ...)
>>>On tape bien un nombre (chaine de caracteres - entiers) en
>>>entree, non ?
toi, tu dois passer me voir! Je constate que tu as mixe reference, tableau
& types
d'une variable!
Prends l'exemple qui suit:
+++++++++++++++++++++++++++++
#include <iostream.h>
void test(char & k)
{
k = 'i';
}
int main()
{
char a = '\0';
char &j = a;
cout << a << endl; // ""
test(a);
cout << a << endl; // "i"
a = 'g';
cout << a << endl; // "g"
test(j);
cout << a << endl; // "i"
return (0);
}
+++++++++++++++++++++++++++++
Que je passe a ou j (une reference a 'a') ou est le probleme? Les deux
appels sont corrects.
Maintenant pour l'histoire du tableau, encore une fois:
int T[10];
je veux initialiser mon tableau (ces 10 composantes) a zero, je ne vais pas ecrire:
T=0!!!!
ni passer un autre tableau et ecrire:
X[0]=0; X[1]=0;X[2]=0 ..... X[9]=0;
puis:
T[0] = X[0];
T[1] = X[1];
...
T[9] = X[9];
Soit X une variable elle vaut 0, alors :
T[0] = X; T[1]= X etc.
regardes ce que j'ai ecrit:
-----------------------------------------------------
initialise la taille du vecteur à taille et la chaîne
à data
-----------------------------------------------------
chaine a data ou a x ou a y ou a z, peut importe. L'essentiel
a une valeur donnee, dans ce
cas un caractere, car c'est un tableau de caracteres. Je t'aurais mis
un tableau d'entiers
et ca aurait ete un entier etc.
bref si c'est toujours confus pour toi, je prefere que tu passes me
voir.
Mohamed Lokbani.
=======================================================================================
Subject: [IFT1166] Questions/Reponses
---TP2--- -4-
Date: Sat, 30 Oct 1999 18:09:28 -0400
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Bonjour,
au menu ....
-1- Des questions a propos de la classe <string>.
Votre demonstrateur vous a donne des exemples d'utilisation de
la classe <string> lors de la demo04, du 6 Octobre 1999. Voir
la solution de cette demo sur la page web du cours.
Voir aussi un exemple d'utilisation de cette classe, poste dans mon email:
[IFT1166] Questions/Reponses ---TP2--- -3-
-2- Il y a aussi une question sur la creation de bibliotheques et l'edition
de liens.
Mohamed Lokbani.
-------------------------------------------------------------------------
Question 1
==========
>>>>Petite question au sujet du constructeur de la classe GrdEnt.
>>>>---> GrdEnt(const string&);
>>>>1) Voulez-vous vraiment que l'on utilise la classe string appatenant
à
>>>>string.h???
>>>> (Voir page 5, Spécification 4)
ou as tu lu dans le texte de l'enonce "string.h"??????
tu utilises la classe <string> du C++. <string.h> fait reference
au langage C.
>>>>2) Voulez-vous que l'on utilise le type pointeur de caractère
(char *)
>>>>comme parametre du constructeur
Non, tu laisses le constructeur comme il est. Examines l'exemple que
j'ai poste
hier, tu vas voir comment j'ai utilise ce constructeur.
>>>>Je pose cette question car j'ai une erreur à la compilation
à chaque
>>>>fois que j'utilise la classe string.
>>>>Pour le prouver, j'ai crée un programme toto.cpp très
simple qui
>>>>contient....
>>>>#include <iostream.h>
>>>>#include <string.h>
>>>>int main()
>>>>{
>>>> string maChaine;
>>>> return 0;
>>>>}
>>>>Pour compiler, je fais... g++ -Wall -o toto toto.cpp
>>>>Erreur de compilation!!!
Ton erreur est due au fait que tu crois que <string> derive de <string.h> or ce n'est pas le cas.
Au lieu d'ecrire cela:
>>>>#include <string.h>
tu dois ecrire ce qui suit:
#include <string>
la le compilateur va appeler la classe string du C++, et tu verras que ca va marcher!
--------------------------------------------------------------------------------------
Question 2
==========
>>>>C'est a propos de la declaration du 3eme constructeur pour
>>>>la classe Representation.
>>>>Representation (int taille, const char & data); // unitialise
la taille
>>>>du vecteur // a taille et la chaine a data
>>>>En fait, je ne comprends pas tres bien le sens du parametre 'data'.
>>>>Celui-ci ainsi declare, est un caractere et non une chaine, et
donc
>>>>on ne peut comparer 'data' avec 'maListe', non ?
>>>>N'aurait-il ete pas mieux d'ecrire,
>>>>Representation (int taille, const char & data[]); // unitialise
la
>>>>taille du vecteur // a taille et la chaine a data
la declaration est bonne.
Regardes ce que j'ai ecrit:
// initialise la taille du vecteur à taille et la chaîne à data
Si je te dis qu'un tableau T de Taille N elements est initialise a zero,
-1- tu vas faire quoi?
-2- est-ce que tu es oblige de passer un tableau de zero? Une valeur
te suffit, Non?
--------------------------------------------------------------------------------------
Question 3
==========
>>>>Petite question : pourriez-vous indiquer les fonctions qui remplissent
>>>>les taches suivantes (et leur fonctionnement...)
>>>>-transformation d'un char en int(et pas conversion du code ASCII du char).
A ma connaissance, tu dois la coder. La raison est qu'elle est dependante
de
la base de ta representation. Dans notre cas c'est la base 10.
>>>>-test si un char est numerique ou alphabetique.
isdigit de <cctype> fera bien l'affaire (est d'origine <ctype.h>
de la bibliotheque C).
--------------------------------------------------------------------------------------
Question 4
==========
>>>>Pourriez-vous indiquer l'essentiel du fonctionnement de la classe
>>>>string, que vous nous demandez d'utiliser, ainsi que les fonctions
qui
votre demonstrateur vous a donne un apercu lors de la demo4.
tu peux trouver l'essentiel ds le livre de Delannoy, chapitre 22, page 511.
Tu n'auras pas besoin de connaitre beaucoup de choses, l'exemple que
j'ai poste
hier pourrait t'aider (tout depend ce que tu cherches).
>>>>realisent les actions suivantes (et dans quelle librairie elles
se
>>>>trouvent):
>>>>-Conversion d'un char numerique vers son int correspondant (et pas
son
>>>>code ASCII).
>>>>-Test si un char est numerique ou alphabetique.
voir la question 4.
--------------------------------------------------------------------------------------
Question 5
==========
>>>>Dans le fichier "spgm.cpp", j'ai le programme principal C++, dans
mon
>>>>fichier exemple.cpp, c'est les fonctions que utilise mon programme
>>>>principal.
>>>>voici les commandes que je fais:
>>>>gcc -c exemple.cpp -o exemple.o
>>>>ar -r libexemple.a exemple.o //creation
du librairie statique
>>>>Quand je fais le commande suivant:
>>>>gcc -L. -o spgm -lexample
>>>>il ya le message suivant: "undefined reference to 'main'"
>>>>Alors, j'aimerais savoir comment on peut resoudre ce probleme?
>>>>Ou on peut definie 'main'(dans quelle librairie)?
il te manque la source!
>>>>gcc -L. -o spgm -lexample
Respectes l'ordre d'appel: la source avant la bibliotheque.
gcc -I. -L. o spgm spgm.cpp -lexample
force le I. pour qu'il cherche les fichiers include en premier de la
ou il compile.
de preference utilises g++ au lieu de gcc. Assez souvent les administrateurs
des parcs logiciels creent deux versions: g++ specifique a la compilation
des
fichiers c++ et gcc specifique a la compilation des fichiers c. S'ils
ont
construit leur architecture de la sorte, tu rateras certaines choses
lors de
la compilation et/ou edition de liens. Pour le voir regardes si gcc
pointe sur g++
ou vis-versa (ls -la gcc et ls -la g++). S'ils sont differents, i.e
y a pas un lien
symbolique qui les lie (et sont aussi de la meme version: g++ -v ou
gcc -v) c'est qu'ils
ont bricole quelque chose en plus dans l'un mais pas dans l'autre,
assez souvent
lors de la generation de l'executable via un Makefile specifique pour
chaque version.
TOPQUESTION
=======================================================================================
Subject: [IFT1166] Questions/Reponses
---TP2--- -3-
Date: Fri, 29 Oct 1999 18:31:16 -0400
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
Bonjour,
>>>1) Pourquoi dans la classe Representation on doit faire que les chiffres
>>>sont renverse (ie. 6475 devient 5746)?
>>>Je ne vois pas pourquoi on doit faire ca? Ne serait-il pas plus
facile
>>>de lire 6475 comme etant 6475 au lieu de l'inverser pour ensuite
le
>>>mettre en ordre?
oui c'est plus facile de lire 6475 comme 6475.
A moi de te poser cette question:
est-ce plus facile de coder (pas lire(!), mais ecrire le programme necessaire):
6475 comme 6475 ou comme 5746?
Si tu ne vois pas la nuance dans les deux representations, je te demande
alors de faire ce petit exercice:
representes avec un dessin (un tableau) les deux chiffres suivants:
en premier representes dans ton tableau le chiffre:
6475
puis quand tu auras termine ton dessin, reprends le comme il est (ne
changes
rien, sauf les valeurs), et representes moi ce chiffre:
86475
ou est-ce que tu vas placer le 8? a la case tab[-1]???? ou bien tu vas
deplacer tes
valeurs d'une case vers la droite (et surcharger ton programme en consequence)!
Si tu as une idee de genie simple qui permettrait de coder cela sans
duplication de code
inutile, ok carte blanche. Sinon, histoire de t'eviter de perdre ton
temps pour trouver
cette idee (qui au passage existe), tu suis les indications du TP!
Effectivement c'est plus facile a lire, mais quand tu commences a coder
l'algorithme
qui doit supporter ton idee, tu vas vite comprendre qu'il te faut cogiter
un peu plus
pour pouvoir le faire correctement. Alors autant garder cette facilite
dans le codage
que dans la lecture.
Idem pour la multiplication, il y a "1001" algorithmes pour la faire,
dans l'enonce j'ai donne
le plus simple, si vous voulez utiliser le plus compliquer libre a
vous de le faire. Lors de
la correction, nous allons preter attention a la maniere avec laquelle
vous avez code
cette complication.
>>>2) Pourquoi les operator de comparaison? (ie.operator >=, operator
!=,
>>>etc...) Ca sert a quoi dans le TP au juste? Je ne vois pas l'utilite
de
>>>ces operators dans notre programme puisque on a juste a additionner,
>>>soustraire et multiplier des nombre....on ne les compare pas....
parce que tu fais une classe, pas la moitie d'une classe, ni les 3/4 ni les 99%!
De cette classe j'ai deliberement retire l'operation de division. Cette
operation necessite
plus d'attention pour sa realisation.
Moi je t'ai donne un programme qui permet de tester au moins 3 operations
("au moins",
car avec un peu de reflexion dans la maniere avec laquelle tu vas ecrire
ton code, tu peux
tester les autres operations de manieres implicites). Mon programme
est utile dans le
sens ou tu peux resoudre ton tp pas a pas. Si mon programme de test
(i.e.calculette) ne
t'arrange pas, ecrits un autre pour ton utilisation personnelle, cependant,
je ne veux pas de
ce programme dans les fichiers que tu vas remettre.
Tu peux aussi utiliser cet exemple
-------------------------------
#include <iostream>
#include <string>
#include "grdent.h"
int main() {
const string s = "8745845689425985785492787548754875487954";
GrdEnt A(s);
GrdEnt C(s);
GrdEnt B(1);
int i=1;
cout << (A+B) << endl; //8745845689425985785492787548754875487955
cout << (A+=B) << endl; //8745845689425985785492787548754875487955
A = C; // je remets la valeur de depart
cout << (A-B) << endl; //8745845689425985785492787548754875487953
cout << (A-=B) << endl; //8745845689425985785492787548754875487953
A = C; // je remets la valeur de depart
cout << (A*B) << endl; //8745845689425985785492787548754875487954
cout << (A*=B) << endl; //8745845689425985785492787548754875487954
A = C; // je remets la valeur de depart
cout << (A*=i) << endl; //8745845689425985785492787548754875487954
A = C; // je remets la valeur de depart
cout << (A==B) << endl; // 0
cout << (A!=B) << endl; // 1
cout << (A<B) << endl; // 0
cout << (A>B) << endl; // 1
//etc.
return 0;
}
-------------------------------
Le programme d'evaluation qui va prendre ton code, lui va comporter
tous les tests y
compris les tests logiques. Je ne vais pas te decrire la procedure
qui sera utilisee pour
corriger vos programmes (!), je te dirai simplement que nous allons
tester de facon
automatique toutes les operations demandees. Nous analyserons aussi,
a la maniere du
TP1, votre listing. Histoire de voir a tete reposee si votre maniere
de coder les choses a
evolue depuis le TP1.
Mohamed Lokbani.
TOPQUESTION
=======================================================================================
Subject:
[IFT1166] Questions/Reponses ---TP2--- -2-
Date: Thu, 28 Oct 1999 15:16:18 -0400
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Bonjour
votre demonstrateur m'a informe des quelques questions
posees lors de la demo d'hier soir a propos du tp2.
ci-joint donc qcqs reponses et qcqs recommandations pour le tp2.
pour d'autres questions, vous savez comment nous joindre.
Mohamed Lokbani.
-----------------------------------------------------------
-1- affichage entrees/sorties
=============================
-1.a-
SVP, N'Utilisez pas a tord et a travers le "cout" dans votre code,
sauf dans le cas -1.b- (voir plus bas).
Ceci dit, Vous pouvez vous en servir pour tester des fragements de votre code.
MAIS apres vos tests, mettez les lignes contenant un "cout" en commentaire.
Une autre facon serait de les entourez de la declaration #define puis
#endif, exemple:
#define montest
cout << " ce que vous voulez ...." << endl;
#endif
a la compilation, si vous voulez utiliser cout vous faites:
g++ -Wall -Dmontest vos_programmes_etc
voir la solution de la demo4 ou j'ai detaille en haut et en large l'utilisation d'un #define.
-1.b-
vous avez besoin d'un ostream pour afficher les chiffres, lors de la surcharge de l'operateur <<
ds ce cas ok, mais contentez-vous d'afficher le nombre pas besoin de commentaires supplementaires!
exemple:
int i =10; // le ostream est dans ce cas "cout"
cout << i; // largement suffisant!
cout << "i " << i; // pas besoin du "i"
remarquez que j'ai meme supprime le "endl"!
dans mon programme main, a moi de coloriez la sortie comme je le desire!
Vous, vous devez juste vous contenter de coder l'outil de sortie pour
qu'il imprime sur la sortie ostream correctement le type demande dans
le
format demande voir pour cela la specification du TP2, Section 3, Paragraphe
2 (l'exemple).
-1.c-
pour les tests d'erreur, feu vert pour diriger vos messages sur la sortie "cerr"
exemple (supposez que vous vouliez x >=0) et je pars entrer une valeur negative:
if (x < 0) {
cerr " j'ai un probleme etc. .... " << endl;
exit (1);
}
-2- classes GrdEnt & Representation
===================================
pourquoi en faire deux, mais pas une seule?
J'ai demande ce decoupage a des fins pedagogiques et pratiques.
pratiques
=========
Quand vous allez construire la classe Representation vous
allez vous rendre compte par vous meme que cette classe
peut etre utilisee telle quelle dans d'autres applications.
pedagogiques
============
vous allez apprendre a manipuler l'interaction entre les deux
classes, la compilation de plusieurs fichiers a la fois
ayant chacun sa propre classe etc.
Je pouvais simplifier le probleme en modifiant sa representation,
mais vous seriez passes a cote de certains "petits details" tres utiles.
-3- tester vos classes
======================
Quand il faut resoudre un probleme, deja il faut comprendre
ce qu'il est demande. A partir de la, je pars faire une petite
etude comment, je peux le resoudre de facon efficace.
Une approche serait de decomposer le probleme en sous problemes.
Dans votre cas, la question serait, comment je peux faire des
petits bouts de code et m'assurer qu'ils marchent! Et puis
si ca marche, comment rassembler les morceaux pour constituer
le tout!
Dans ce qui suit, je fais l'hypothese que vous savez deja
ce qu'on vous demande, donc je vous donne des tuyaux comment
vous pouvez decomposer votre probleme en sous problemes.
Vous pouvez vous passer de cette approche, et sautez au point 4.
-3.a-
En premier: ecrivez deja les classes GrdEnt & Representation,
sans inclure la surcharge des differents operateurs.
Puis tenter de compiler vos programmes a la maniere indiquee
sur l'enonce du TP2.
S'il y a ce niveau des problemes, ne partez pas loin, essayez
deja de les resoudre.
-3.b-
Supposez que ca compile, allez a l'etape deux et ecrivez le code
necessaire pour surcharger les operateurs.
Au depart pas besoin d'aller surcharger tous les operateurs, vous
avez besoin juste du +=
Pourquoi?
si vous examinez le fichier "partage.h" vous allez trouver ce
passage:
// fichier contenant les fonctions du programme calculette
// Parmi ces fonctions, les 3 operations disponibles pour tester
// vos programmes.
// Si A & B sont deux grands entiers
// Ces operations sont: A+=B ; A-=B ; A*=B
donc au depart contentez-vous de surcharger que += ou -+ ou *=
puis recompilez votre code.
ca passe tres bien voir 3.c! Ca casse, pas besoin d'aller tres loin!
problemes a resoudre ....
-3.c-
supposez que ca compile:
la vous pouvez utiliser le programme de la calculette avec
une des operations que vous avez surchargee (exemple le +=)
le programme va vous demander un chiffre en entree (prenez un tres
large chiffre), puis l'operation, la vous choisisez le + (si vous avez
surcharge le +=), puis le deuxieme chiffre (prenez un petit chiffre,
histoire d'eviter de perdre son temps a faire sur un petit bout de
papier
l'addition soi-meme!), et vous allez obtenir le resultat.
Si le resultat est bon, surchargez les autres operateurs dans l'ordre
(-=, *= car vous pouvez utilisez le programme de la calculette pour
les
tester), puis les autres operateurs.
Si vous obtenez un resultat errone, vous avez un bug!
-4- constructeurs
=================
a titre indicatif (i.e. vous etes tenus a respecter la specification,
mais
pas ma facon de coder), je vous donne comment serait l'appel du constructeur
de la classe GrdEnt dans le cas ou je lui passe une valeur entiere:
GrdEnt::GrdEnt(int nombre)
// postcondition: GrdEnt est initialise a nombre
// j'initialise les membres de la classe GrdEnt avec des valeurs "bidon"
: monsigne(positif), // j'ai mis le signe a positif
Digits(1,'0'), // Digits est du type Representation,
et contient donc
// deux membres prives: maTaille ET maListe je me dis
// que j'ai une liste de taille 1, et contient le caractere zero.
NbreDigits(0) // le nbre de chiffres que le
nombre contient, je le mets a 0.
{
// et
puis je pars faire ma petite cuisine ....
}
-------------------------------
sans les commentaires:
GrdEnt::GrdEnt(int nombre)
: monsigne(positif),
Digits(1,'0'),
NbreDigits(0)
{
// et puis je pars
faire ma petite cuisine ....
}
TOPQUESTION
=======================================================================================
Subject:
[IFT1166] Questions/Reponses --- TP2 --- -1-
Date: Mon, 25 Oct 1999 14:53:55 -0400
From: Mohamed Lokbani <lokbani@IRO.UMontreal.CA>
To: gift1166@IRO.UMontreal.CA
--------------------------------------------------
Bonjour,
>>>Dans la declaration a l'indexation de la classe Represenration,
>>>J'aurais deux remarques a faire :
>>>(1) Ne faudrait-il pas ajouter en parametre un entier qui permet
>>>de selectionner l'element que l'on desire retourner.
je n'ai pas voulu donner toutes les definitions des fonctions pour eviter
de
reduire ce tp, a un questionnaire du style oui/non ou vous n'auriez
rien a faire ...
J'ai du definir quelques fonctions pour eviter des surprises et surtout
assurer que le programme de la calculette puisse marcher avec votre
code.
Puisque tu as souleve la question: tu dois passer donc comme argument
un
entier!
>>>(2) A quoi sert de mettre la reference & si l'on ecrit que la
valeur
>>>de l'objet est constant ?
>>>En conclusion ne faudrait-il pas plutot ecrire,
>>>char operator [] (int) const
>>>au lieu de
>>>const char & operator []
tu as raison, il y a eu une omission dans l'enonce!
Donc j'ai ecrit au niveau du :
5. Spécification formelle des membres de la classe Representation
page 6 (tout debut) dans la partie
---------------------------------------------------
indexation
const char & operator [ ] // retourne le k ème élément
---------------------------------------------------
il fallait lire:
-------------------------------------------------------
const char & operator [ ] const // retourne le k ème élément
-------------------------------------------------------
Il manquait donc le "const" a la fin de la seconde ligne.
Il y a a peu pres 15 jours nous avions entame le cours de surcharge
des
operateurs, ou j'ai pris comme exemple, la surchage des operateurs
pour une classe tableau.
Lors de notre prochaine rencontre, toujours sur le meme exemple, je
vais
decrire la surcharge de l'operateur d'indexation. Et je vais montrer
la necessite d'une
double surcharge, comme celle de la classe Representation.
Des que j'aurai un moment, Je vais remettre a jour l'enonce.
Merci pour la remarque, si vous en avez d'autres n'hesitez pas a les
mentionner.
Mohamed Lokbani.
TOPQUESTION
=======================================================================================