Chapitres traités    Utilisation de char[] et de char* Classe "Chaine - Light" Classe "Chaine" complète La classe Pôlynome

Utilisation d'un tableau de char ou d'un pointeur de char

Tapez ces lignes de code. Vous testerez chacune de ces lignes en utilisant le debugger en mode pas à pas F8. Pour chacune de variables utilisées, établissez systématiquement l'adresse de la variable ainsi que son contenu complet (Utilisez le mode Inspection). Si vous avez à faire à des pointeurs, donnez l'adresse de la variable, l'adresse de la variable pointée et le contenu complet de la variable pointée. Faites systématiquement une représentation schématique.

Expliquez ce qui se passe pour la ligne :

1. Donnez l'adresse de la variable bonjour. Donnez son contenu complet. Donnez la taille de la variable. Y a t'il des cases non utilisées ? Peut-on lui affecter plus tard une autre adresse ?
2. Donnez l'adresse de la variable salut. A quoi correspond son contenu ? Evaluer son contenu ? Son contenu peut-il varier ? Où se situe la chaîne « salut ». Déterminez son adresse. Quelle est sa taille ?
3. Donnez l'adresse de la variable message. Quelle est la valeur de son contenu ? Est-ce que cette valeur est cohérente ? A quoi correspond normalement ce type de valeur ?
4. Donnez l'adresse de la variable bienvenue. A quoi correspond son contenu ? Evaluer son contenu ? Son contenu peut-il varier ? Ou se situe la chaîne représentée par char[10]. Déterminez son adresse. Quelle est sa taille ? Quelle est sa valeur ? Sa valeur est-elle cohérente ?
5. Que se passe t-il sur cette ligne ? Evaluer son contenu ? A quoi correspond son contenu ? Que devient la chaîne représentée par char[10]. Est-elle toujours accessible ? Est-ce que l'instruction new char[10] a un sens ? Qu'est-ce qu'il aurait fallu faire pour que cette expression ait un sens ? Avec l'écriture proposée, y a t-il perte de mémoire ?
6. Que se passe t-il sur cette ligne ? Evaluer son contenu ? A quoi correspond son contenu ?
7. Que se passe t-il sur cette ligne ? Evaluer son contenu ? A quoi correspond son contenu ? Que devient la chaîne « salut ». Est-elle toujours accessible ?
8. Quelle est la chaîne de caractères modifiée ?
9. Quelle est la chaîne de caractères modifiée ?
10. Quelle est la chaîne qui est libérée ? Est-ce que la chaîne représentée par new char[10] a été libérée ?

Analyse de la classe « Chaîne » version « Light »

Nous allons mettre en œuvre une classe Chaîne qui permettra de palier aux problèmes que nous venons de mettre en évidence pus haut avec les chaînes de type < char* >.

Avant de réellement commencer, nous allons faire une première approche avec juste quelques méthodes implémentées. Cette classe rudimentaire est constituée de deux attributs. D'une part l'attribut chaîne qui représentera en interne la chaîne réelle, et d'autre part l'attribut taille qui comme son nom l'indique donnera la dimension de la chaîne.

A partir de ces considérations :

1. Quel est l'intérêt de prendre comme un attribut un pointeur. N'aurait-il pas été préférable de choisir plutôt un tableau ? quel est le meilleur choix d'après vous et pourquoi ?
   
2. Le destructeur est-il nécessaire ?
   
3. Tester le programme ci-contre. Placez le point d'arrêt comme indiqué sur la ligne return 0. Evaluer à l'aide du debugger les objets bonjour, salut et bienvenue. Récoltez les informations nécessaires pour bien comprendre le fonctionnement interne, notamment toutes les adresses des différents pointeurs. Que remarquez-vous sur la valeur de ces différents objets (au moment où le curseur d'exécution se situe sur la dernière instruction) ? Ce comportement est-il souhaitable ? Que faudra t-il faire pour éviter ce disfonctionnement ?
   
4. Tout en ayant le curseur d'exécution sur la dernière ligne du programme (c'est-à-dire sur return 0 ; ), cliquez de nouveau sur Run. Vous constatez que vous avez une exception qui s'est déclenchée. Pour quelle raison ? d'où vient le problème ? Est-ce que le problème est de même nature que la question précédente ?
   
5. Nous avons redéfini l'opérateur [ ]. Pourquoi ai-je placé une référence ? enlevez là et tester le programme de nouveau. Que constatez-vous ? Est-ce que cette référence est obligatoire ?
   
6. La taille proposée à l'intérieur de la chaîne, est-elle la taille réelle ?

Constitution complète de la classe Chaîne

La structure précédente était vraiment loin d'être complète. C'est ce qui d'ailleurs a provoqué de nombreux disfonctionnements. Vous allez au fur et à mesure ajouter de nouveaux comportements à cette classe. A chacune des méthodes rajoutées, vous montrerez votre résultat au professeur. Prenez bien soin de noter toutes les remarques sur feuille.

1. Changer la méthode correspondant à la définition de l'opérateur [ ] pour qu'elle prenne en compte la valeur de l'indice.
   
2. Mettre en œuvre le constructeur de recopie.
   
3. Mettre en œuvre l'opérateur d'affectation.
   
4. Le codage de ces deux nouvelles méthodes comporte de nombreuses similitudes. Proposer alors une nouvelle méthode privée que vous appellerez init qui regroupera les lignes communes et qui sera appelée par ces deux méthodes. Ces dernières seront alors beaucoup plus réduites.
   
5. Redéfinissez l'opérateur d'égalité qui permettra de réaliser un test entre deux chaînes.
   
6. Redéfinissez l'opérateur += pour faire de la concaténation de chaîne.
   
7. Dans le même ordre d'idée, redéfinissez l'opérateur + pour faire également de la concaténation de chaîne. Toutefois, il faudra prendre en compte l'écriture suivante du style : « message »+Chaîne , où « message » représente le type char* .
   
8. Définissez l'opérateur d'entier pour que l'on puisse récupérer une valeur entière écrite au sein d'une chaîne.
   
9. Effectuez l'opération inverse, c'est-à-dire que lorsqu'on propose un entier, il puisse être changé en une chaîne représentant cet entier.

La classe Polynome

Nous allons reprendre la classe Polynome qui, je le rappelle, représente, par exemple, le nombre suivant :

En effet, vous avez remarqué un disfonctionnement au niveau de l'opérateur +, qui n'est finalement pas dû à cette méthode, mais plutôt au fonctionnement du comportement par défaut. En effet, nous avons un tableau dynamique d'objets au sein de cette classe. Il est donc préférable de redéfinir le comportement par défaut afin que la fiabilité soit au rendez-vous.

La classe Rationnel ne nécessite aucun changement du comportement par défaut. Par contre, la classe Diviseurs peut également poser des problèmes, puisqu'elle dispose également en son sein d'un tableau dynamique. Comme il s'agit d'une classe plutôt utilitaire, vous pouvez faire en sorte de bloquer la construction par copie ainsi que l'affectation, afin d'éviter justement les copies membre à membre qui, dans ce cas là, peuvent mal se passer.

#include "Polynome.h"
//------------------------------------------------------------------------------
int main()
{
  Polynome p(3);
  p.setCoef(0, 5);
  p.setCoef(1, Rationnel(3, 2));
  p.setCoef(2, Rationnel(7,4, Negatif));
  p.setCoef(3, 10);
  Polynome p1 = Rationnel(8, 5, Negatif);
  Rationnel r[] = { 8, Rationnel(5, 2, Negatif), 7, Rationnel(7, 1, Negatif)};
  Polynome p2(3, r);
  p.getCoef(1).setDenominateur(4);
  Polynome p3(3);
  p3 = p + p2;
  return 0;
}
//------------------------------------------------------------------------------

Utiliser le debugger pour bien tester le fonctionnement global. Vous en profiterez pour bien contrôler le cheminement des appels des méthodes respectives.