[[PageOutline]]


= Objet Simples =

L'objectif de  ce premier TME est  de bien se familiariser  avec les mécanismes
base régissant le fonctionnement d'un  objet C++. Plus particulièrement sur les
constructeurs & destructeurs,  et les contextes dans lesquels  ils peuvent être
appelés.

== Présentation du Code ==

Comme il a été  annoncé en cours un soin tout particulier  devra être accordé à
la présentation de  votre code. A cet effet un  exemple type d'indentation vous
est fourni ci-après. Toujours pour une meilleure lisibilité, réduisez la taille
des tabulations à  2 ou 4 caractères  au lieu du defaut de  8. Enfin, n'insérez
jamais  le caractère ''tabulation''  dans votre  code source,  configurez votre
éditeur favori  pour que celui-çi  substitue automatiquement des  espaces blanc
ordinaires à la place d'une tabulation.

Pour  '''{{{vim}}}'''/'''{{{gvim}}}''', ajouter  dans votre  {{{~/.vimrc}}} les
lignes suivantes:
{{{
:set shiftwidth=2
:set expandtab

:autocmd FileType c,cpp set cindent
:autocmd FileType make set noexpandtab shiftwidth=8
}}}

Pour '''{{{emacs}}}''', ajoutez dans votre {{{~/.emacs}}} les lignes suivantes:
{{{
;; CC-Mode configuration.
 (defun local-c-mode-hook ()
  (setq c-echo-syntactic-information-p t
                        c-basic-offset 2
                             tab-width 4
                      indent-tabs-mode nil)
  (c-set-offset 'topmost-intro          0)
  (c-set-offset 'inclass              '++)
  (c-set-offset 'access-label          '-)
  (c-set-offset 'comment-intro         '-)
  (c-set-offset 'arglist-cont-nonempty 'c-lineup-arglist-close-under-paren)
  (c-set-offset 'arglist-close         'c-lineup-arglist-close-under-paren)
  (c-set-offset 'defun-block-intro     '+)
  (c-set-offset 'statement-block-intro '+)
  (c-set-offset 'block-close            0)
  (c-set-offset 'case-label            '+)
  (c-set-offset 'statement-case-intro  '+))
 (add-hook 'c-mode-common-hook 'local-c-mode-hook)
 
 (setq auto-mode-alist
  (cons '("\\.\\(h\\|hh\\|hpp\\)\\'" . c++-mode)
   auto-mode-alist))
}}}

[[Image(indentation-1.png,70%,align=center)]]


== Compilation ==

Dans le  cadre de ce  premier TME,  nous allons nous  contenter de faire  de la
compilation monolithique. C'est à dire que tout le code de chaque exercice sera
contenu dans  un seul fichier  source, par exemple  {{{Box.cpp}}}. L'éxécutable
sera créé par compilation de cet unique fichier.

Compilation monolithique d'un fichier source:
{{{
g++ -Wall -g -o box Box.cpp
}}}

Ici,  l'éxécutable généré  sera  {{{box}}}. Attention  l'argment {{{-o}}}  doit
immédiatement être suivi du nom de l'éxécutable ({{{box}}}).

Autres arguments donnés à {{{g++}}}:
* {{{-g}}}  demande  d'inclure le  code  nécessaire  pour  pouvoir utiliser  un
  débogueur ({{{gdb}}} ou {{{ddd}}}).
* {{{-Wall}}} demande d'afficher tous  les avertissements. Vous devrez toujours
  utiliser ce  drapeau ({{{flag}}})  et à  l'issue de la  mise au  point, votre
  programme ne devra générer aucun avertissement.


== Mon Premier Objet: {{{Box}}} ==

Nous allons implémenter la classe {{{Box}}} présentée en cours.

[[Image(box-1.png,30%,align=center)]]

'''Attention''', dans  le récapitulatif  suivant, les prototypes  des fonctions
membre ne sont  pas forcément donnés de façon exacte.  Votre travail consiste à
les achever conformément à ce qui a été vu en cours (et au bon sens).

La classe {{{Box}}} comporte les cinq attributs suivants:
* {{{_name}}} : le petit nom de l'objet courant (de type {{{std::string}}}).
* {{{_x1, _y1,  _x2, y2}}} :  les coordonnées des  deux angles de la  boite (de
  type {{{int}}}).

Les coordonnées  {{{_x1}}} et {{{_y1}}} (respectivement  {{{_y1}}} et {{{_y2}}}
seront  maintenues  ordonnées telles  que  {{{_x1  <=  _x2}}}. Une  boite  sera
considérée comme vide si {{{_x1 > _x2}}} ou {{{_y1 > _y2}}}.

Constructeurs: (''CTOR'')
* {{{Box()}}}, constructeur par défaut. Doit construire une boîte vide.
* {{{Box(const std::string&, int  x1, int y1, int x2,  int y2)}}}, constructeur
  ''ordinaire''.
* {{{Box(const  Box&)}}},   constructeur  par  copie.  Pour   plus  de  clarté,
  lorsqu'une  boite sera  copiée on  s'autorisera  à en  modifier le  nom en  y
  ajoutant le suffixe {{{"_c"}}}.

Destructeur: (''DTOR'')
* {{{~Box()}}}, destructeur (unique).

Accesseurs: (''accessors'')
* {{{getName()}}}
* {{{getX1()}}}
* {{{getY1()}}}
* {{{getX2()}}}
* {{{getY2()}}}
* {{{isEmpty()}}}
* {{{intersection(const Box&)}}}
* {{{print(std::ostream&)}}} : affiche l'état de  la {{{Box}}} dans un flux, on
  choisi le format suivant: {{{<"NAME" x1 y1 x2 y2>}}}.

Modificateurs: (''mutators'')
* {{{makeEmpty()}}}
* {{{inflate(int dxy)}}}
* {{{inflate(int dx, int dy)}}}
* {{{inflate(int dx1, int dy1, int dx2, int dy2)}}}
* {{{getIntersection(const Box&)}}}

Afin de pouvoir bien suivre  les appels aux constructeurs & destructeurs durant
l'éxécution du programme, nous allons  ajouter des affichages dans les corps de
ces fonctions.  Ils devront afficher: (huit espaces blancs en début de ligne)

{{{
        Box::Box() <"NAME" x1 y1 x2 y2>
        Box::Box(const std::string&, ...) <"NAME" x1 y1 x2 y2>
        Box::Box(const Box&) <"NAME" x1 y1 x2 y2>
        Box::~Box() <"NAME" x1 y1 x2 y2>
}}}


=== Question 1 ===

Implanter la classe {{{Box}}} comme  spécifié précedemment. Pour la valider, on
utilisera le programme de test  fourni çi-après. L'éxécution de ce programme va
produire une  trace d'éxecution indiquant  à quel endroits les  contructeurs et
destructeurs sont appelés. Commentez la  trace en mettant en correspondance les
appels et les instructions du programme.

Programme de test à utiliser pour valider votre classe:
[[Image(BoxMain.png,75%,align=center)]]



=== Question 2 ===

Vérification des droits d'accès: tour à tour, déplacer chaque constructeur dans
la partie {{{private}}}  de la classe {{{Box}}}. Recompiler,  que se passe-t-il
et pourquoi.


=== Question 3 ===

On  désire ajouter  une nouvelle  méthode  {{{getCenter()}}} à  la classe,  qui
renvoie  les  coordonnées {{{(x,y)}}}  du  centre  de  la boite.  Proposer  une
implantation de cette méthode ainsi qu'un petit programme de test.


=== Question 4 ===

Exercice de style:

Pour illustrer les concepts d'{{{API}}} et d'encapsulation, nous allons changer
la représentation interne de la {{{Box}}}. Les attributs deviennent:

* {{{_x}}} et {{{_y}}}: le centre de la boite.
* {{{_width}}} et {{{_height}}} : la taille de la boite.

Réimplémenter  la   classe  en   utilisant  ces  nouveaux   attributs.  Quelles
conséquences cela a-t-il sur le programme de test?