Compilation des questions/reponses du TP2
 

--------------------------------------------------
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

TOP

TOPQUESTION

=======================================================================================

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.
 

TOP

TOPQUESTION

=======================================================================================

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;
}
 

TOP

TOPQUESTION

=======================================================================================
 

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.

TOP

TOPQUESTION

=======================================================================================

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

}

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

TOP

TOPQUESTION

=======================================================================================

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.
 

TOP

TOPQUESTION

=======================================================================================

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.
 

TOP

TOPQUESTION

=======================================================================================

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.
 

TOP

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.

TOP

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 ....
}
 

TOP

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.

TOP

TOPQUESTION
=======================================================================================