Penser en C++

Une bibliothèque commence habituellement comme une collection de fonctions, mais si vous avez utilisé des bibliothèques C écrites par autrui, vous savez qu'il s'agit généralement de plus que cela, parce que la vie ne se limite pas à des comportements, des actions et des fonctions. On y trouve également des caractéristiques (bleu, livres, texture, luminance), qui sont représentées par des données. Et lorsque vous commencez à travailler avec un ensemble de caractéristiques en C, il est très pratique de les rassembler dans une structure, particulièrement si vous désirez représenter plus d'un objet similaire dans l'espace de votre problème. De cette manière, vous pouvez définir une variable du type de cette structure pour chaque objet.

Ainsi, la plupart des bibliothèques C se composent d'un ensemble de structures et d'un ensemble de fonctions qui agissent sur ces structures. Comme exemple de ce à quoi un tel système peut ressembler, considérez un objet qui se comporte comme un tableau, mais dont la taille peut être établie à l'exécution, lors de sa création. Je l'appellerai CSTash. Bien qu'il soit écrit en C++, il utilise un style qui correspond à ce que vous écririez en C:

//: C04:CLib.h
// Fichier d'en-tête pour une bibliothèque
// écrite dans le style C
// Un entité semblable à un tableau créée à l'exécution
 
typedef struct CStashTag {
  int size;      // Taille de chaque espace
  int quantity;  // Nombre d'espaces de stockage
  int next;      // Prochain espace libre
  // Tableau d'octets alloué dynamiquement:
  unsigned char* storage;
} CStash;
 
void initialize(CStash* s, int size);
void cleanup(CStash* s);
int add(CStash* s, const void* element);
void* fetch(CStash* s, int index);
int count(CStash* s);
void inflate(CStash* s, int increase);
///:~

Un nom tel que CStashTag est généralement employé pour une structure au cas où vous auriez besoin de référencer cette structure à l'intérieur d'elle-même. Par exemple, lors de la création d'une liste chaînée(chaque élément dans votre liste contient un pointeur vers l'élément suivant), vous avez besoin d'un pointeur sur la prochaine variable struct, vous avez donc besoin d'un moyen d'identifier le type de ce pointeur au sein du corps même de la structure. Aussi, vous verrez de manière presque universelle le mot clé typedef utilisé comme ci-dessus pour chaque struct présente dans une bibliothèque C. Les choses sont faites de cette manière afin que vous puissiez traiter une structure comme s'il s'agissait d'un nouveau type et définir des variables du type de cette structure de la manière suivante:

CStash A, B, C;

Le pointeur storage est de type unsigned char*. Un unsigned char est la plus petite unité de stockage que supporte un compilateur C, bien que, sur certaines machines, il puisse être de la même taille que la plus grande. Cette taille dépend de l'implémentation, mais est souvent de un octet. Vous pourriez penser que puisque CStash est conçu pour contenir n'importe quel type de variable, void* serait plus approprié. Toutefois, l'idée n'est pas ici de traiter cet espace de stockage comme un bloc d'un type quelconque inconnu, mais comme un bloc contigu d'octets.

Le code source du fichier d'implémentation (que vous n'obtiendrez pas si vous achetez une bibliothèque commerciale - vous recevrez seulement un obj, ou un lib, ou un dll, etc. compilé) ressemble à cela:

//: C04:CLib.cpp {O}
// Implantation de l'exemple de bibliothèque écrite
// dans le style C
// Declaration de la structure et des fonctions:
#include "CLib.h"
#include <iostream>
#include <cassert> 
using namespace std;
// Quantité d'éléments à ajouter
// lorsqu'on augmente l'espace de stockage:
const int increment = 100;
 
void initialize(CStash* s, int sz) {
  s->size = sz;
  s->quantity = 0;
  s->storage = 0;
  s->next = 0;
}
 
int add(CStash* s, const void* element) {
  if(s->next >= s->quantity) //Il reste suffisamment d'espace?
    inflate(s, increment);
  // Copie l'élément dans l'espace de stockage,
  // en commençant au prochain espace vide:
  int startBytes = s->next * s->size;
  unsigned char* e = (unsigned char*)element;
  for(int i = 0; i < s->size; i++)
    s->storage[startBytes + i] = e[i];
  s->next++;
  return(s->next - 1); // Numéro de l'indice
}
 
void* fetch(CStash* s, int index) {
  // Vérifie les valeurs limites de l'indice:
  assert(0 <= index);
  if(index >= s->next)
    return 0; // Pour indiquer la fin
  // Produit un pointer sur l'élément désiré:
  return &(s->storage[index * s->size]);
}
 
int count(CStash* s) {
  return s->next;  // Eléments dans CStash
}
 
void inflate(CStash* s, int increase) {
  assert(increase > 0);
  int newQuantity = s->quantity + increase;
  int newBytes = newQuantity * s->size;
  int oldBytes = s->quantity * s->size;
  unsigned char* b = new unsigned char[newBytes];
  for(int i = 0; i < oldBytes; i++)
    b[i] = s->storage[i]; // Copie l'ancien espace vers le nouveau
  delete [](s->storage); // Ancien espace
  s->storage = b; // Pointe sur le nouvel espace mémoire
  s->quantity = newQuantity;
}
 
void cleanup(CStash* s) {
  if(s->storage != 0) {
   cout << "freeing storage" << endl;
   delete []s->storage;
  }
} ///:~

initialize() effectue le travail d'initialisation pour la structure CStash en fixant les variables internes à une valeur appropriée. Initialement, le pointeur storage est mis à zéro - aucun espace de stockage n'est alloué.

La fonction add() insère un élément dans le CStash à la prochaine position disponible. D'abord, elle contrôle s’il reste de l'espace à disposition. Si ce n'est pas le cas, elle étend l'espace de stockage en utilisant la fonction inflate(), décrite plus loin.

Parce que le compilateur ne connait pas le type spécifique de la variable stockée (tout ce que la fonction reçoit est un void*), vous ne pouvez pas simplement faire une affectation, ce qui serait certainement chose pratique. À la place, vous devez copier la variable octet par octet. La manière la plus évidente de réaliser cette copie est par itération sur les indices d'un tableau. Typiquement, storage contient déjà des octets de données, ce qui est indiqué par la valeur de next. Afin de démarrer avec le décalage d'octets approprié, next est multiplié par la taille de chaque élément (en octets) de manière à produire startBytes. Puis, l'argument element est converti en un unsigned char* de façon telle qu'il peut être adressé octet par octet et copié dans l'espace de stockage disponible. next est incrémenté de manière à indiquer le prochain emplacement disponible, et l'« indice » où la valeur a été placée afin de pouvoir récupérer cette dernière en utilisant cet indice avec fetch().

fetch() vérifie que l'indice n'est pas en dehors des limites et retourne l'adresse de la variable désirée, calculée à l'aide de l'argument index. Puisque index représente le nombre d'éléments à décaler dans CStash, il doit être multiplié par le nombre d'octets occupés par chaque entité pour produire le décalage numérique en octets. Lorsque ce décalage est utilisé pour accéder à un élément de storage en utilisant l'indiçage d'un tableau, vous n'obtenez pas l'adresse, mais au lieu de cela l'octet stocké à cette adresse. Pour produire l'adresse, vous devez utiliser l'opérateur adresse-de&.

count() peut au premier abord apparaître un peu étrange au programmeur C expérimenté. Cela ressemble à une complication inutile pour faire quelque chose qu'il serait probablement bien plus facile de faire à la main. Si vous avez une structure CStash appelée intStash, par exemple, il semble bien plus évident de retrouver le nombre de ses éléments en appelant inStash.next plutôt qu'en faisant un appel de fonction (qui entraine un surcoût), tel que count(&intStash). Toutefois, si vous désirez changer la représentation interne de CStash, et ainsi la manière dont le compte est calculé, l'appel de fonction apporte la flexibilité nécessaire. Mais hélas, la plupart des programmeurs ne s'ennuieront pas à se documenter sur la conception « améliorée » de votre bibliothèque. Ils regarderont la structure et prendront directement la valeur de next, et peut-être même qu'ils modifieront next sans votre permission. Si seulement il y avait un moyen pour le concepteur de bibliothèque d'obtenir un meilleur contrôle sur de telles opérations! (Oui, c'est un présage.)

V-A-1. Allocation dynamique de mémoire▲

new unsigned char[newBytes];

new int;

delete []myArray;

//: C04:CLibTest.cpp
//{L} CLib
// Teste la bibliothèque écrite dans le style C
#include "CLib.h"
#include <fstream>
#include <iostream>
#include <string>
#include <cassert>
using namespace std;
 
int main() {
  // Définit les variables au début
  // d'un bloc, comme en C:
  CStash intStash, stringStash;
  int i;
  char* cp;
  ifstream in;
  string line;
  const int bufsize = 80;
  // Maintenant, rappelez-vous d'initialiser les variables:
  initialize(&intStash, sizeof(int));
  for(i = 0; i < 100; i++)
    add(&intStash, &i);
  for(i = 0; i < count(&intStash); i++)
    cout << "fetch(&intStash, " << i << ") = "
         << *(int*)fetch(&intStash, i)
         << endl;
  // Contient des chaines de 80 caractères:
  initialize(&stringStash, sizeof(char)*bufsize);
  in.open("CLibTest.cpp");
  assert(in);
  while(getline(in, line))
    add(&stringStash, line.c_str());
  i = 0;
  while((cp = (char*)fetch(&stringStash,i++))!=0)
    cout << "fetch(&stringStash, " << i << ") = "
         << cp << endl;
  cleanup(&intStash);
  cleanup(&stringStash);
} ///:~

cp = (char*)fetch(&stringStash,i++)

V-A-2. Mauvaises conjectures▲

Nous avons des capacités d'adaptation remarquables, y compris dans les situations dans lesquelles nous ne devrions peut-être pas nous adapter. Le modèle de la bibliothèque CStash était une entrée en matière destinée aux programmeurs en langage C, mais si vous la regardiez pendant un moment, vous pourriez noter qu'elle est plutôt… maladroite. Quand vous l'employez, vous devez passer l'adresse de la structure à chaque fonction de la bibliothèque. En lisant le code, le mécanisme de fonctionnement de la bibliothèque se mélange avec la signification des appels de fonction, ce qui crée la confusion quand vous essayez de comprendre ce qui se passe.

Un des obstacles majeurs à l'utilisation de bibliothèques C est cependant le problème de collision des noms. C possède un espace de nom unique pour les fonctions; c'est-à-dire que, quand l'éditeur de liens recherche le nom d'une fonction, il regarde dans une liste principale unique. De plus, quand le compilateur travaille sur une unité de traduction, il ne peut travailler qu'avec une seule fonction ayant un nom donné.

Supposez maintenant que vous décidiez d'acheter deux bibliothèques différentes à deux fournisseurs différents, et que chaque bibliothèque dispose d'une structure qui doit etre initialisée et nettoyée. Chaque fournisseur décide que initialize( ) et cleanup( ) sont des noms adaptés. Si vous incluez leurs deux fichiers d'en-tête dans une même unité de traduction, que fait le compilateur C? Heureusement, C vous donne une erreur, et vous indique qu'il y a une disparité dans les deux listes d'arguments des fonctions déclarées. Mais même si vous ne les incluez pas dans la même unité de traduction, l'éditeur de lien aura toujours des problèmes. Un bon éditeur de liens détectera qu'il y a une collision de noms, mais certains autres prendront le premier nom qu'ils trouvent, en cherchant dans la liste de fichiers objet selon l'ordre dans lequel vous les lui avez donnés. (Ce peut même être considéré comme une fonctionnalité du fait qu'il vous permet de remplacer une fonction de bibliothèque par votre propre version.)

D'une manière ou d'une autre, vous ne pourrez pas utiliser deux bibliothèques C contenant une fonction ayant un nom identique. Pour résoudre ce problème, les fournisseurs de bibliothèques ajouteront souvent une séquence unique de caractères au début de tous les noms de leurs fonctions. Ainsi initialize( ) et cleanup( ) deviendront CStash_initialize( ) et CStash_cleanup( ). C'est une chose logique à faire, car cela “décore” le nom de la fonction avec le nom de la struct sur laquelle elle travaille.

Maintenant, il est temps de suivre la première étape vers la création de classes en C++. Les noms de variables dans une struct n'entrent pas en collision avec ceux des variables globales. Alors, pourquoi ne pas tirer profit de ceci pour des noms de fonctions, quand ces fonctions opèrent sur une struct particulière ? Autrement dit, pourquoi ne pas faire des fonctions membres de struct ?

La première étape est exactement celle-là. Les fonctions C++ peuvent être placées à l'intérieur de structures sous la forme de « fonctions membres ». Voilà à quoi peut ressembler le code après conversion de la version C de CStash en une version C++ appelée Stash:

//: C04:CppLib.h
// Bibliothèque dans le style C convertie en C++
 
struct Stash {
  int size;      // Taille de chaque espace
  int quantity;  // Nombre d'espaces de stockage
  int next;      // Prochain emplacement libre
   // Allocation dynamique d'un tableau d'octets:
  unsigned char* storage;
  // Fonctions!
  void initialize(int size);
  void cleanup();
  int add(const void* element);
  void* fetch(int index);
  int count();
  void inflate(int increase);
}; ///:~

Tout d'abord, notez qu'il n'y a pas de typedef. À la place de vous demander de créer un typedef, le compilateur C++ transforme le nom de la structure en un nouveau nom de type disponible pour le programme (de la même manière que int, char, float et double sont des noms de type).

Tous les membres données sont exactement les mêmes que précédemment, mais maintenant, les fonctions se trouvent à l'intérieur du corps de la structure. Par ailleurs, notez que le premier argument présent dans la version C de la bibliothèque a été éliminé. En C++, au lieu de vous forcer à passer l'adresse de la structure en premier argument de toutes les fonctions qui agissent sur cette structure, le compilateur le fait secrètement à votre place. Maintenant, les seuls arguments passés aux fonctions concernent ce que la fonction fait, et non le mécanisme sous-jacent lié au fonctionnement de cette fonction.

C'est important de réaliser que le code des fonctions est effectivement le même que dans la version C de la bibliothèque. Le nombre d'arguments est le même (même si vous ne voyez pas l'adresse de la structure, elle est toujours là), et il y a exactement un corps de fonction pour chaque fonction. C'est-à-dire que le simple fait d'écrire

Stash A, B, C;

ne signifie pas une fonction add() différente pour chaque variable.

Ainsi, le code généré est presque identique à celui que vous auriez écrit pour la version C de la bibliothèque. De manière assez intéressante, cela inclut la « décoration des noms » que vous auriez probablement mise en œuvre afin de produire Stash_initialize(), Stash_cleanup(), etc. Lorsque le nom de fonction se trouve à l'intérieur d'une structure, le compilateur réalise effectivement les mêmes opérations. C'est pourquoi initialize() situé à l'intérieur de la structure Stash n'entre pas en collision avec une fonction appelée initialize() située dans une autre structure, ou même avec une fonction globale nommée initialize(). La plupart du temps vous n'avez pas besoin de vous préoccuper de la décoration des noms de fonctions - vous utilisez les noms non décorés. Mais parfois, vous avez besoin de pouvoir spécifier que cet initialize() appartient à la structure Stash, et pas à n'importe quelle autre structure. En particulier, lorsque vous définissez la fonction, vous avez besoin de spécifier de manière complète de quelle fonction il s'agit. Pour réaliser cette spécification complète, C++ fournit un opérateur ( ::) appelé opérateur de résolution de portée(appelé ainsi, car les noms peuvent maintenant exister sous différentes portées: à un niveau global ou au sein d'une structure). Par exemple, si vous désirez spécifier initialize(), qui appartient à Stash, vous écrivez Stash::initialize(int size). Vous pouvez voir ci-dessous comment l'opérateur de résolution de portée est utilisé pour la définition de fonctions:

//: C04:CppLib.cpp {O}
// Bibliothèque C convertie en C++
// Déclare une structure et des fonctions:
#include "CppLib.h"
#include <iostream>
#include <cassert>
using namespace std;
// Quantité d'éléments à ajouter
// lorsqu'on augmente l'espace de stockage:
const int increment = 100;
 
void Stash::initialize(int sz) {
  size = sz;
  quantity = 0;
  storage = 0;
  next = 0;
}
 
int Stash::add(const void* element) {
  if(next >= quantity) // Reste-il suffisamment de place?
    inflate(increment);
  // Copie element dans storage,
  // en commençant au prochain espace libre:
  int startBytes = next * size;
  unsigned char* e = (unsigned char*)element;
  for(int i = 0; i < size; i++)
    storage[startBytes + i] = e[i];
  next++;
  return(next - 1); // Numéro d'indice
}
 
void* Stash::fetch(int index) {
  // Check index boundaries:
  assert(0 <= index);
  if(index >= next)
    return 0; // Pour indiquer la fin
  // Retourne un pointeur sur l'élément désiré:
  return &(storage[index * size]);
}
 
int Stash::count() {
  return next; // Nombre d'éléments dans CStash
}
 
void Stash::inflate(int increase) {
  assert(increase > 0);
  int newQuantity = quantity + increase;
  int newBytes = newQuantity * size;
  int oldBytes = quantity * size;
  unsigned char* b = new unsigned char[newBytes];
  for(int i = 0; i < oldBytes; i++)
    b[i] = storage[i]; // Copie l'ancien dans le nouveau
  delete []storage; // Ancienne espace 
  storage = b; // Pointe vers le nouvel espace mémoire
  quantity = newQuantity;
}
 
void Stash::cleanup() {
  if(storage != 0) {
    cout << "freeing storage" << endl;
    delete []storage;
  }
} ///:~

Il y a plusieurs autres points qui diffèrent entre C et C++. Tout d'abord, les déclarations dans les fichiers d'en-tête sont requises par le compilateur. En C++, vous ne pouvez pas appeler une fonction sans la déclarer d'abord. Faute de quoi, le compilateur vous renverra un message d'erreur. C'est une manière importante de s'assurer que les appels de fonctions sont cohérents entre l'endroit où elles sont appelées et l'endroit où elles sont définies. En vous forçant à déclarer une fonction avant de l'appeler, le compilateur C++ s'assure virtuellement que vous réaliserez cette déclaration en incluant le fichier d'en-tête. Si vous incluez également le même fichier d'en-tête à l'endroit où les fonctions sont définies, alors le compilateur vérifie que la déclaration dans l'en-tête et dans la définition de la fonction correspondent. Cela signifie que le fichier d'en-tête devient un dépôt validé de déclarations de fonctions et assure que ces fonctions seront utilisées d'une manière cohérente dans toutes les unités de traduction du projet.

Bien entendu, les fonctions globales peuvent toujours être déclarées à la main à chaque endroit où elles sont définies et utilisées. (C'est si ennuyeux à réaliser que cette manière de faire est très improbable.) Toutefois, les structures doivent toujours être déclarées avant qu'elles soient définies ou utilisées, et l'endroit le plus approprié pour y placer la définition d'une structure, c'est dans un fichier d'en-tête, à l'exception de celles que vous masquez intentionnellement dans un fichier.

Vous pouvez observer que toutes les fonctions membres ressemblent à des fonctions C, à l'exception de la résolution de portée et du fait que le premier argument issu de la version C de la bibliothèque n'apparaît plus de façon explicite. Il est toujours là, bien sûr, parce que la fonction doit être en mesure de travailler sur une variable struct particulière. Mais notez qu'à l'intérieur d'une fonction membre, la sélection du membre a également disparu! Ainsi, à la place d'écrire s->size = sz; vous écrivez size = sz; et éliminez le s-> ennuyeux, qui n'ajoutait de toute manière véritablement rien au sens de ce que vous vouliez faire. Le compilateur C++ fait cela à votre place. En fait, il utilise le premier argument « secret » (l'adresse de la structure que nous passions auparavant à la main) et lui applique le sélecteur de membre à chaque fois que vous faites référence à une donnée membre de cette structure. Cela signifie qu'à chaque fois que vous vous trouvez à l'intérieur d'une fonction membre d'une autre structure, vous pouvez faire référence à n'importe quel membre (inclus une autre fonction membre) en utilisant simplement son nom. Le compilateur recherchera parmi les noms locaux à la structure avant de rechercher une version globale du même nom. Vous vous rendrez compte que cette fonctionnalité signifie que votre code sera non seulement plus facile à écrire, il sera aussi beaucoup plus facile à lire.

Mais que se passe-t-il si, pour une raison quelconque, vous désirez manipuler l'adresse de la structure? Dans la version C de la bibliothèque, c'était facile, car le premier argument de chaque fonction était un pointeur de type CStash* appelé s. En C++, les choses sont encore plus cohérentes. Il y a un mot clé spécial, appelé this, qui produit l'adresse de la structure. C'est l'équivalent de s dans la version C de la bibliothèque. Ainsi, on peut retrouver le style utilisé en C en écrivant:

this->size = Size;

Le code généré par le compilateur est exactement le même, si bien que vous n'avez pas besoin d'utiliser this de cette manière; occasionnellement, vous verrez du code où les gens utilisent this-> partout de façon explicite, mais cela n'ajoute rien à la signification du code et c'est souvent révélateur d'un programmeur inexpérimenté. Habituellement, vous n'utilisez pas souvent this, mais lorsque vous en avez besoin, il est là (certains des exemples que vous rencontrerez plus loin dans le livre utilisent this).

Il reste un dernier point à mentionner. En C, vous pouvez affecter un pointeur de type void* à n'importe quel autre pointeur de la façon suivante:

int i = 10;
void* vp = &i; // OK aussi bien en C qu'en C++
int* ip = vp; // Acceptable uniquement en C

et il n'y avait aucune plainte de la part du compilateur. Mais en C++, cette instruction n'est pas autorisée. Pourquoi? Parce que C n'est pas aussi précis au sujet de l'information de type, ainsi il vous autorise à affecter un pointeur avec un type non spécifié à un pointeur avec un type spécifié. Rien de cela avec C++. Le typage est une chose critique en C++, et le compilateur sort ses griffes lorsqu'il aperçoit des violations au sujet de l'information de type. Ça a toujours été important, mais ça l'est spécialement en C++, parce que vous avez des fonctions membres à l'intérieur des structures. Si vous pouviez passer des pointeurs de struct n'importe comment en toute impunité en C++, il est possible que vous finissiez par appeler une fonction membre pour une structure qui n'existe même pas pour la structure effectivement traitée! Une voie directe vers le désastre. Par conséquent, tandis que C++ autorise l'affectation de n'importe quel type de pointeur à un void* (c'était la raison d'être originelle de void*, qui a la contrainte d'être suffisamment grand pour contenir un pointeur de n'importe quel type), il ne vous permettra pas d'affecter un pointeur void à n'importe quel autre type de pointeur. Une conversion est toujours nécessaire pour avertir le lecteur et le compilateur que vous voulez véritablement le traiter comme le type de destination.

Ce point soulève un aspect intéressant. Un des objectifs importants de C++ est de compiler autant de code C existant que possible afin de permettre une transition aisée vers ce nouveau langage. Malgré tout, cela ne signifie pas que n'importe quel code autorisé en C sera automatiquement accepté en C++. Il y a de nombreuses choses qu'un compilateur C laisse passer qui sont dangereuses et susceptibles d'entrainer des erreurs. (Nous les étudierons au fur et à mesure que le livre progresse.) Le compilateur C++ génère des avertissements et des erreurs dans ces situations. Il s'agit là souvent plus d'un avantage que d'un obstacle. En fait, il existe de nombreuses situations où vous essayez de traquer une erreur en C et ne parvenez pas à la trouver, mais aussitôt que vous recompilez le programme en C++, le compilateur montre le problème du doigt! En C, vous vous rendrez souvent compte que vous pouvez amener le programme à compiler, mais que la prochaine étape est de le faire fonctionner correctement. En C++, lorsque le programme compile comme il le doit, souvent en plus, il fonctionne! C'est parce que le langage est beaucoup plus strict avec les types.

Vous pouvez voir un certain nombre de nouvelles choses dans la façon dont la version C++ de Stash est utilisée dans le programme de test suivant:

//: C04:CppLibTest.cpp
//{L} CppLib
// Test de la bibliothèque C++
#include "CppLib.h"
#include "../require.h"
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
 
int main() {
  Stash intStash;
  intStash.initialize(sizeof(int));
  for(int i = 0; i < 100; i++)
    intStash.add(&i);
  for(int j = 0; j < intStash.count(); j++)
    cout << "intStash.fetch(" << j << ") = "
         << *(int*)intStash.fetch(j)
         << endl;
  // Contient des chaines de 80 caractères
  Stash stringStash;
  const int bufsize = 80;
  stringStash.initialize(sizeof(char) * bufsize);
  ifstream in("CppLibTest.cpp");
  assure(in, "CppLibTest.cpp");
  string line;
  while(getline(in, line))
    stringStash.add(line.c_str());
  int k = 0;
  char* cp;
  while((cp =(char*)stringStash.fetch(k++)) != 0)
    cout << "stringStash.fetch(" << k << ") = "
         << cp << endl;
  intStash.cleanup();
  stringStash.cleanup();
} ///:~

Une chose que vous noterez, c'est que les variables sont toutes définies « à la volée » (comme introduit au chapitre précédent). C'est-à-dire qu'elles sont définies à n'importe quel endroit au sein d'un bloc, au lieu d'être contraintes - comme en C - de l'être au début du bloc.

Le code est relativement similaire à CLibTest.cpp, mais lorsqu'une fonction membre est appelée, l'appel a lieu en utilisant l'opérateur de sélection de membre ' .' précédé par le nom de la variable. C'est une syntaxe pratique parce qu'elle imite la sélection d'un membre donnée de la structure. La différence est qu'il s'agit là d'une fonction membre, et qu'elle possède une liste d'arguments.

Bien entendu, l'appel que le compilateur génère effectivement ressemble beaucoup plus à la fonction originale de la bibliothèque C. Ainsi, en considérant la décoration du nom et le passage de this, l'appel de fonction C++ inStash.initialize(sizeof(int), 100) devient quelque chose comme Stash_initialize(&intStash, sizeof(int), 100).Si vous vous demandez un jour ce qui se passe sous le capot, souvenez-vous que cfront, le compilateur C++ original de AT&T, produisait en sortie du code C qui était alors compilé par un compilateur C sous-jacent. Cette approche signifiait que cfront pouvait être rapidement porté sur n'importe quelle machine possédant un compilateur C, et cela a contribué à favoriser la dissémination rapide de la technologie du compilateur C++. Mais, parce que le compilateur C++ devait générer du C, vous savez qu'il doit être possible, d'une manière ou d'une autre, de représenter la syntaxe C++ en C (certains compilateurs vous permettent encore de produire du code C).

Il ya un autre changement par rapport à CLibTest.cpp qui consiste en l'introduction du fichier d'en-tête require.h. Il s'agit d'un fichier d'en-tête que j'ai créé pour ce livre afin d'effectuer une vérification d'erreur plus sophistiquée que celle fournie par assert(). Il contient plusieurs fonctions dont celle utilisée ici et appelée assure(), qui est utilisée pour les fichiers. Cette fonction contrôle que le fichier a été ouvert avec succès, et dans le cas contraire, affiche sur le flux d'erreur standard que le fichier n'a pu être ouvert (elle a donc besoin du nom du fichier en second argument) et quitte le programme. Les fonctions de require.h seront utilisées tout au long de ce livre, en particulier pour nous assurer que la ligne de commande comporte le bon nombre d'arguments et que les fichiers sont ouverts proprement. Les fonctions de require.h remplacent le code de vérification d'erreur répétitive et qui constitue une distraction, et fournissent essentiellement des messages d'erreur utiles. Ces fonctions seront expliquées de façon de complète plus loin dans le livre.

Maintenant que vous avez vu un premier exemple, il est temps de faire marche arrière et de jeter un œil à la terminologie. Le fait d'apporter des fonctions dans une structure est la base de ce que le C++ apporte au C, et cela introduit une nouvelle façon de penser les structures: comme des concepts. En C, une struct est une agglomération de données, un moyen d'empaqueter les données de manière à ce que vous puissiez les traiter dans un bloc. Mais il est difficile d'y penser autrement que comme une commodité de programmation. Les fonctions qui agissent sur ces structures sont ailleurs. Cependant, avec les fonctions dans le paquetage, la structure devient une nouvelle créature, capable de décrire à la fois des caractéristiques (comme le fait une struct C) et des comportements. Le concept de l'objet, une entité libre et bornée qui peut se souvenir et agir, se suggère de lui-même.

En C++, un objet est simplement une variable, et la plus pure définition est “une zone de stockage” (c'est un moyen plus spécifique de dire, “un objet doit avoir un identifiant unique”, qui dans le cas du C++ est une adresse mémoire unique). C'est un emplacement dans lequel vous pouvez stocker des données, et qui implique qu'il y a également des opérations qui peuvent être effectuées sur ces données.

Malheureusement, il n'y a pas complète uniformité entre les langages sur ces termes, bien qu'ils soient assez bien acceptés. Vous rencontrerez parfois des désaccords sur ce qu'est un langage orienté objet, bien que cela semble raisonnablement bien défini maintenant. Il y a des langages qui sont à base d'objets, ce qui signifie qu'il y a des objets comme les structures avec fonctions du C++ que vous avez vu jusqu'à présent. Ce n'est cependant qu'une partie de la condition nécessaire à un langage orienté objet, et les langages qui s'arrêtent à l'empaquetage des fonctions dans les structures de données sont à base d'objets, et non orientés objet.

La capacité d'empaqueter des données avec des fonctions vous permet de créer de nouveaux types de données. Cela est généralement appelé encapsulation(32). Un type de donnée existant peut avoir plusieurs morceaux de données empaquetées ensemble. Par exemple, un float a un exposant, une mantisse, et un bit de signe. Vous pouvez lui dire de faire des choses: l'ajouter à un autre float ou à un int, et ainsi de suite. Il a des caractéristiques et un comportement.

La définition de Stash crée un nouveau type de données. Vous pouvez ajouter ( add( )), chercher ( fetch( )), et gonfler ( inflate( )). Vous en créez un en disant Stash s, tout comme vous créez un float en disant float f. Un Stash a aussi des caractéristiques et un comportement. Bien qu'il se comporte comme un type réel, intégré, nous nous y référons comme à un type de données abstrait, peut-être parce qu'il nous permet d’abstraire un concept de l'espace des problèmes vers l'espace des solutions. En plus, le compilateur C++ le traite comme un nouveau type de données, et si vous dites qu'une fonction attend un Stash, le compilateur s'assurera que vous passiez un Stash à cette fonction. Ainsi le même niveau de vérification de type se produit avec les types de données abstraits (parfois appelés types définis par l'utilisateur) qu'avec les types intégrés.

Vous pouvez immédiatement voir la différence, cependant, à la façon dont vous effectuez des opérations sur les objets. Vous dites object.memberFunction(arglist). C'est “l'appel d'une fonction membre pour un objet.” Mais dans le jargon orienté objet, c'est également mentionné comme “l'envoi d'un message à un objet.” Pour un Stash s, l'instruction s.add(&i) envoie à s un message disant, « ajoute-toi ceci.” En réalité, la programmation orientée objet peut se résumer en une seule phrase: envoyer des messages à des objets. C'est vraiment tout ce que vous faites – créer un groupe d'objets et leur envoyer des messages. L'astuce, bien sûr, est de vous représenter ce que sont vos objets et vos messages , mais une fois que vous l'avez fait, l'implémentation en C++ est étonnamment simple.

Une question qui revient souvent dans les séminaires est “Quelle est la taille d'un objet, et à quoi ressemble-t-il ?” La réponse dépend “ce que vous voulez faire d'un struct C.” En fait, le code que le compilateur C produit pour un struct C (avec aucun ornement C++) est souvent exactement le même que celui produit par un compilateur C++. C'est rassurant pour ces programmeurs C qui se reposent sur les détails de taille et de disposition de leur code, et qui,pour certaines raisons, accédent directement aux octets de la structure au lieu d'employer des identifiants (compter sur une taille et une disposition particulières pour une structure est une activité non portable).

La taille d'une structure est la taille combinée de tous ses membres. Quelquefois quand le compilateur génère un struct, il ajoute des octets supplémentaires pour faire ressortir nettement les frontières – ceci peut augmenter l'efficacité de l'exécution. Dans le Chapitre 15, vous verrez comment dans certains cas des pointeurs “secrets” sont ajoutés à la structure, mais vous n'avez pas besoin de vous en soucier pour l'instant.

Vous pouvez déterminer la taille d'un struct en utilisant l'opérateur sizeof. Voici un petit exemple:

//: C04:Sizeof.cpp
// Taille des structures
#include "CLib.h"
#include "CppLib.h"
#include <iostream>
using namespace std;
 
struct A {
  int   i[100];
};
 
struct B {
  void f();
};
 
void B::f() {}
 
int main() {
  cout << "sizeof struct A = " << sizeof(A) << " bytes" << endl;
  cout << "sizeof struct B = " << sizeof(B) << " bytes" << endl;
  cout << "sizeof CStash in C = " << sizeof(CStash) << " bytes" << endl;
  cout << "sizeof Stash in C++ = " << sizeof(Stash) << " bytes" << endl;
} ///:~

Sur ma machine (vos résultats peuvent varier) le premier rapport d'impression donne 200 parce que chaque int occupe deux octets. struct B est une espèce d'anomalie parce que c'est un struct sans données membres. En C c'est illégal, mais en C++ nous avons besoin de pouvoir créer une structure dont la tache est d'étendre les noms de fonctions, et c'est donc autorisé. Dans tous les cas, le résultat produit par le deuxième rapport d'impression est une valeur non nulle un peu étonnante. Dans les premières versions du langage, la taille était zéro, mais une situation maladroite surgit quand vous créez de tels objets : ils ont la même adresse que l'objet créé directement après eux, ils sont donc indistincts. Une des règles fondamentales des objets est que chaque objet a une adresse unique, ainsi les structures sans données membres ont toujours une taille minimale non nulle.

Les deux derniers sizeof vous montrent que la taille de la structure en C++ est la même que la taille de la version équivalente en C. Le C++ essaie de ne pas ajouter de suppléments inutiles.

Lorsque vous créez une structure contenant des fonctions membres, vous êtes en train de créer un nouveau type de donnée. En général, vous voulez que ce type soit facilement accessible à vous-même et aux autres. Par ailleurs, vous désirez séparer l'interface (la déclaration) de l'implémentation (la définition des fonctions membres) de manière à ce que l'implémentation puisse être modifiée sans forcer une recompilation du système entier. Vous y parvenez en plaçant les déclarations concernant votre nouveau type dans un fichier d'en-tête.

Lorsque j'ai d'abord appris à programmer en C, le fichier d'en-tête était un mystère pour moi. Beaucoup d'ouvrages sur le C ne semblent pas mettre l'accent dessus, et le compilateur n'imposait pas les déclarations de fonction, de telle manière que j'avais la plupart du temps l'impression que c'était optionnel, sauf quand des structures étaient déclarées. En C++, l'usage de fichiers d'en-tête devient clair comme de l'eau de roche. Ils sont obligatoires pour un développement de programme facile, et on y place des informations très spécifiques: les déclarations. Le fichier d'en-tête informe le compilateur de ce qui est disponible dans votre bibliothèque. Vous êtes en mesure d'utiliser la bibliothèque même si vous ne possédez que le fichier d'en-tête, ainsi que le fichier objet ou le fichier de bibliothèque. Vous n'avez pas besoin du code source du fichier cpp. Le fichier d'en-tête est l'endroit où est sauvegardée la spécification de l'interface.

Bien que ce ne soit pas imposé par le compilateur, la meilleure approche pour construire de grands projets en C est d'utiliser des bibliothèques; collecter des fonctions associées dans un même module objet ou bibliothèque, et utiliser un fichier d'en-tête pour contenir toutes les déclarations de fonctions. Cette pratique est de rigueur en C++. Vous pouviez placer n'importe quelle fonction dans une bibliothèque C, mais le type abstrait de donnée du C++ détermine les fonctions associées par leur accès commun aux données d'une même structure. N'importe quelle fonction membre doit être déclarée dans une déclaration de structure. Vous ne pouvez pas le faire ailleurs. L'usage de bibliothèques de fonctions était encouragé en C, mais institutionnalisé en C++.

V-G-1. L'importance des fichiers d'en-tête▲

printf(...);

V-G-2. Le problème des déclarations multiples▲

V-G-3. Les directives #define, #ifdef et #endif du préprocesseur▲

#define FLAG

#define PI 3.14159

#ifdef FLAG

#endif

#endif // FLAG

V-G-4. Un standard pour les fichiers d'en-tête▲

#ifndef HEADER_FLAG
#define HEADER_FLAG
// Ici vient la déclaration du type...
#endif // HEADER_FLAG

//: C04:Simple.h
// Simple header that prevents re-definition
#ifndef SIMPLE_H
#define SIMPLE_H
 
struct Simple {
  int i,j,k;
  initialize() { i = j = k = 0; }
};
#endif // SIMPLE_H ///:~

V-G-5. Les espaces de nommage dans les fichiers d'en-tête▲

using namespace std;

V-G-6. Utiliser des fichiers d'en-tête dans des projets▲

La commodité de sortir les noms de données et de fonctions de l'espace de nom global s'étend aux structures. Vous pouvez imbriquer une structure dans une autre, ce qui conserve les éléments associés ensemble. La syntaxe de la déclaration est celle à laquelle on peut s'attendre, comme vous pouvez le voir dans la structure suivante, qui implémente une pile classique au moyen d'une liste simplement chaînée de manière à ce qu'elle ne manque « jamais » de mémoire:

//: C04:Stack.h
// struct imbriquée dans une liste chaînée
#ifndef STACK_H
#define STACK_H
 
struct Stack {
  struct Link {
    void* data;
    Link* next;
    void initialize(void* dat, Link* nxt);
  }* head;
  void initialize();
  void push(void* dat);
  void* peek();
  void* pop();
  void cleanup();
};
#endif // STACK_H ///:~

Le struct imbriqué s'appelle Link, et il contient un pointeur sur le prochain Link dans la liste ainsi qu'un pointeur sur la donnée stockée dans le Link. Si le pointeur next vaut zéro, cela signifie que vous êtes à la fin de la liste.

Notez que le pointeur head est défini juste après la déclaration du struct Link, au lieu d'une définition séparée Link* head. C'est une syntaxe issue du C, mais cela souligne l'importance du point-virgule après la déclaration de structure; le point-virgule indique la fin de la liste des définitions pour ce type de structure. Les divers éléments de cette liste de définitions sont séparés par une virgule. (Généralement la liste est vide.)

La structure imbriquée possède sa propre fonction initialize( ), comme toutes les structures vues précédemment, pour assurer son initialisation correcte. Stack possède les deux fonctions initialize( ) et cleanup( ), ainsi que push( ), qui prend en paramètre un pointeur sur le data que vous voulez stocker (elle considère qu'il a été alloué sur le tas), et pop( ), qui retourne le pointeur de data se trouvant en haut de la pile avant de le supprimer du haut de la pile. (quand vous dépilez - pop( )- un élément, vous êtes responsable de la destruction de l'objet pointé par data.) La fonction peek( ) retourne également le pointeur de data se trouvant en haut de la pile, mais elle conserve cet élément en haut de la pile.

Voici les définitions des fonctions membres:

//: C04:Stack.cpp {O}
// Liste chaînée avec imbrication
#include "Stack.h"
#include "../require.h"
using namespace std;
 
void Stack::Link::initialize(void* dat, Link* nxt) {
  data = dat;
  next = nxt;
}
 
void Stack::initialize() { head = 0; }
 
void Stack::push(void* dat) {
  Link* newLink = new Link;
  newLink->initialize(dat, head);
  head = newLink;
}
 
void* Stack::peek() { 
  require(head != 0, "Pile vide");
  return head->data; 
}
 
void* Stack::pop() {  if(head == 0) return 0;
  void* result = head->data;
  Link* oldHead = head;
  head = head->next;
  delete oldHead;
  return result;
}
 
void Stack::cleanup() {
  require(head == 0, "Pile non vide");
} ///:~

La première définition est particulièrement intéressante parce qu'elle vous montre comment définir un membre d'une structure imbriquée. Vous utilisez simplement un niveau supplémentaire de résolution de portée pour spécifier le nom du struct englobant. Stack::Link::initialize( ) prend les arguments et les assigne à ses membres.

Stack::initialize( ) met le pointeur head à zéro, ainsi l'objet sait que sa liste est vide.

Stack::push( ) prend l'argument, qui est un pointeur sur la variable dont vous voulez conserver la trace, et l'ajoute sur le haut de la pile. Pour cela, la fonction commence par utiliser new pour allouer la mémoire pour le Link que l'on va insérer au-dessus. Puis elle appelle la fonction initialize( ) de Link pour assigner les valeurs appropriées aux membres de Link. Notez que le pointeur next est affecté au pointeur head courant; puis le pointeur head est affecté avec la valeur du nouveau pointeur Link. Cela pousse effectivement le Link en haut de la liste.

Stack::pop( ) capture le pointeur data situé sur le haut de la pile; puis fait descendre le pointeur head et supprime l'ancien sommet de la pile, et retourne enfin le pointeur capturé. Quand pop( ) supprime le dernier élément, alors le pointeur head vaut à nouveau zéro, ce qui signifie que la pile est vide.

Stack::cleanup( ) ne fait en fait aucun nettoyage. Au lieu de cela, il établit une politique ferme qui est que “vous (le programmeur client qui utilise cet objet Stack) êtes responsable du dépilement de tous les éléments du Stack et de leur suppression.” require( ) est utilisé pour indiquer qu'une erreur de programmation s'est produite si la pile n'est pas vide.

Pourquoi le destructeur de Stack ne pourrait-il pas être responsable de tous les objets que le programmeur client n'a pas dépilé ? Le problème est que Stack est en possession de pointeurs void, et vous apprendrez au Chapitre 13 qu'appeler delete sur un void* ne nettoie pas les choses proprement. Le fait de savoir “qui est responsable de la mémoire” n'est pas si simple, comme nous le verrons dans les prochains chapitres.

Voici un exemple pour tester la pile Stack:

//: C04:StackTest.cpp
//{L} Stack
//{T} StackTest.cpp
// Test d'une liste chaînée imbriquée
#include "Stack.h"
#include "../require.h"
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
 
int main(int argc, char* argv[]) {
  requireArgs(argc, 1); // Le nom du fichier est passé en argument
  ifstream in(argv[1]);
  assure(in,argv[1]);
  Stack textlines;
  textlines.initialize();
  string line;
  // Lit le fichier et stocke les lignes dans la pile:
    while(getline(in, line))
  textlines.push(new string(line));
  // Dépile les lignes de la pile et les affiche:
  string* s;
  while((s = (string*)textlines.pop()) != 0) {
    cout << *s << endl;
    delete s; 
  }
  textlines.cleanup();
} ///:~

Ceci est similaire à l'exemple précédent, mais on empile des lignes d'un fichier (sous forme de pointeur de string) sur le Stack puis on les dépile, ce qui provoque un affichage inversé du fichier à l'écran. Notez que la fonction membre pop( ) retourne un void* et que celui-ci doit être casté en string* avant de pouvoir être utilisé. Pour afficher le string à l'écran, le pointeur est déférencé.

Comme textlines est rempli, le contenu de line est “cloné” pour chaque push( ) en faisant un new string(line). La valeur retournée par l'expression new est un pointeur sur un nouveau string qui a été créé et qui a copié l'information dans line. Si vous aviez simplement passé l'adresse de line à push(), vous auriez obtenu un Stack rempli d'adresses identiques, pointant toutes vers line. Vous en apprendrez plus à propos de ce processus de “clonage” plus tard dans ce livre.

Le nom de fichier est récupéré depuis la ligne de commande. Pour s'assurer qu'il y ait assez d'arguments dans la ligne de commande, vous pouvez voir l'utilisation d'une deuxième fonction issue du fichier d'en-tête require.h: requireArgs( ), qui compare argc au nombre désiré d'arguments et affiche à l'écran un message d'erreur approprié avant de terminer le programme s'il n'y a pas assez d'arguments.

V-H-1. Résolution de portée globale▲

//: C04:Scoperes.cpp
// Résolution de portée globale
int a;
void f() {}
 
struct S {
  int a;
  void f();
};
 
void S::f() {
  ::f();  // autrement il y aurait récurrence!
  ::a++;  // Sélectionne le a global
  a--;    // Le a dans la portée du struct
}
 
int main() { S s; f(); } ///:~

Dans ce chapitre, vous avez appris le “tournant” fondamental du C++: vous pouvez mettre des fonctions dans les structures. Ce nouveau type de structure est appelé un type de données abstraites, et les variables que vous créez en utilisant ces structures sont appelées objets, ou instances, de ce type. Appeler une fonction membre d'un objet est appelé envoyer un message à cet objet. L'action première en programmation orientée objet est d'envoyer des messages aux objets.

Bien qu'empaqueter les données et les fonctions ensemble apporte un bénéfice considérable à l'organisation du code et simplifie l'utilisation des bibliothèques parce que cela empêche les conflits de noms en les cachant, vous pouvez faire beaucoup plus pour programmer de façon plus sûre en C++. Dans le prochain chapitre, vous apprendrez comment protéger certains membres d'un struct pour que vous soyez le seul à pouvoir les manipuler. Cela établit une frontière claire entre ce que l'utilisateur de la structure peut changer et ce que seul le programmeur peut changer.

Les solutions de exercices suivants peuvent être trouvés dans le document électronique The Thinking in C++ Annotated Solution Guide, disponible à petit prix sur www.BruceEckel.com.

1. Au sein de la bibliothèque standard du langage C, la fonction puts() imprime un tableau de caractères sur la console (ainsi vous pouvez écrire puts(« hello »)). Écrivez un programme C qui utilise puts(), mais n'inclut pas < stdio.h> ou autrement dit déclarez la fonction. Compilez ce programme à l'aide de votre compilateur C. (Certains compilateurs C++ ne sont pas distincts de leur compilateur C; dans ce cas, vous devez rechercher une option à passer à la ligne de commande qui force une compilation C.) Maintenant, compilez-le avec un compilateur C++ et observez la différence.
2. Créez une déclaration de structure avec une fonction membre unique, puis créez une définition pour cette fonction membre. Créez une instance de votre nouveau type de donnée, et appelez la fonction membre.
3. Modifiez votre solution de l'exercice 2 de telle manière à déclarer la structure dans un fichier d'en-tête « protégé » de façon adéquate contre les inclusions multiples, avec la définition de la fonction dans un fichier cpp et votre main() dans un autre.
4. Créez une structure contenant un membre donnée unique de type int, et deux fonctions globales prenant chacune en argument un pointeur sur cette structure. La première fonction prend un second argument de type int et affecte la valeur de cet argument au membre int de la structure, la seconde affiche la valeur du membre int de cette structure. Testez ces fonctions.
5. Répétez l'exercice 4, mais déplacez les fonctions de manière à ce qu'elles soient des fonctions membres de la structure, et testez à nouveau ces fonctions.
6. Créer une classe qui (de façon redondante) effectue la sélection d'un membre donnée ainsi que l'appel d'une fonction membre en utilisant le mot clé this(qui fait référence à l'adresse de l'objet courant).
7. Créer un Stash qui contient des double. Remplissez-le avec 25 valeurs de type double, puis affichez-les sur la console.
8. Répétez l'exercice 7 avec Stack.
9. Créer un fichier contenant une fonction f() qui prend un argument de type int et l'affiche sur la console en utilisant la fonction printf() déclarée dans < stdio.h> en écrivant: printf(« %d
10.  », i) où i est l'entier que vous désirez afficher. Créez un fichier séparé contenant main(), et dans ce fichier, déclarez f() comme prenant un argument de type float. Appelez f() depuis main(). Essayez de compiler et de lier votre programme à l'aide d'un compilateur C++ et observez ce qui se passe. Maintenant compilez et liez ce programme en utilisant un compilateur C, et regardez ce qui se passe lorsqu'il s'exécute. Expliquez les comportements observés.
11. Trouvez comment produire du code assembleur à l'aide de vos compilateurs C et C++. Écrivez une fonction en C et une structure avec une fonction membre unique en C++. Générez les codes assembleur correspondants et recherchez les noms de fonctions qui sont produits par votre fonction C et votre fonction membre C++, de telle manière que vous puissiez voir quelle décoration de nom est mise en œuvre par le compilateur.
12. Écrivez un programme avec du code de compilation conditionnelle au sein de main(), de telle manière que lorsqu'une constante préprocesseur est définie, un message est affiché, alors qu'un autre message est affiché lorsqu'elle n'est pas définie. Compilez ce code en expérimentant avec un #define dans le programme, puis recherchez comment vous pouvez passer des définitions préprocesseur via la ligne de commande et expérimentez.
13. Écrivez un programme qui utilise assert() avec un argument qui est toujours faux (zéro) pour voir ce qui se passe lorsque vous l'exécutez. Maintenant, compilez-le avec #define NDEBUG et exécutez-le à nouveau pour voir la différence.
14. Créez un type abstrait de donnée qui représente une cassette vidéo dans un étalage de location de vidéos. Essayez de considérer toutes les données et opérations qui peuvent être nécessaire au type Video pour se comporter de manière adéquate au sein du système de gestion de location de vidéos. Incluez une fonction membre print() qui affiche les informations concernant la Video.
15. Créer un objet Stack pour contenir les objets Video de l'exercice 13. Créez plusieurs objets Video, stockez-les dans l'objet Stack, et affichez-les en utilisant Video::print().
16. Écrivez un programme qui affiche toutes les tailles des types de données fondamentaux sur votre ordinateur en utilisant sizeof.
17. Modifiez Stash de manière à utiliser un vector<char> comme structure de donnée sous-jacente.
18. Créez dynamiquement des emplacements mémoires pour les types suivants, en utilisant new: int, long, un tableau de 100 char s, un tableau de 100 float. Affichez leurs adresses et puis libérez les espaces alloués à l'aide de delete.
19. Écrivez une fonction qui prend un char* en argument. En utilisant new, allouez dynamiquement un tableau de char qui est de la taille du tableau de char passé à la fonction. En utilisant l'itération sur les indices d'un tableau, copiez les caractères du tableau passé en argument vers celui alloué dynamiquement (n'oubliez pas le marqueur de fin de chaine null) et retournez le pointeur sur la copie. Dans votre fonction main(), testez la fonction en y passant une constante chaine de caractères statique entre guillemets, puis récupérez le résultat et passez-le à son tour à la fonction. Affichez les deux chaines de caractères et les deux pointeurs de manière à vous rendre compte qu'ils correspondent à des emplacements mémoire différents. À l'aide de delete, nettoyez tout l'espace alloué dynamiquement.
20. Montrez un exemple d'une structure déclarée à l'intérieur d'une autre structure (une structure imbriquée). Déclarez des membres données dans chacune des structures, et déclarez et définissez des fonctions membres dans chacune des structures. Écrivez une fonction main() qui teste vos nouveaux types.
21. Quelle est la taille d'une structure? Écrivez un morceau de code qui affiche la taille de différentes structures. Créez des structures qui comportent seulement des données membres et d'autres qui ont des données membres ainsi que des fonctions membres. Puis, créez une structure qui n'a aucun membre du tout. Affichez toutes les tailles correspondantes. Expliquez le pourquoi du résultat obtenu pour la structure ne contenant aucun membre donnée du tout.
22. C++ crée automatiquement l'équivalent d'un typedef pour les structures, comme vous l'avez appris dans ce chapitre. Il fait la même chose pour les énumérations et les unions. Écrivez un petit programme qui démontre cela.
23. Créez un Stack qui contient des Stash. Chaque Stash contiendra 5 lignes d'un fichier passé en entrée. Créez les Stash en utilisant new. Chargez le contenu d'un fichier dans votre Stack, puis réaffichez-le dans sa forme originale en extrayant les données de la structure Stack.
24. Modifiez l'exercice 22 de manière à créer une structure qui encapsule le Stack de Stash. L'utilisateur doit non seulement être en mesure d'ajouter et d'obtenir des lignes par l'intermédiaire de fonctions membres, mais sous le capot, la structure doit utiliser un Stack de Stash.
25. Créez une structure qui contient un int et un pointeur sur une autre instance de la même structure. Écrivez une fonction qui prend l'adresse d'une telle structure et un int indiquant la longueur de la liste que vous désirez créer. Cette fonction créera une chaine entière de ces structures (une liste chaînée), en démarrant à la position indiquée par l'argument (la tête de la liste), chaque instance pointant sur la suivante. Créez les nouvelles structures en utilisant new, et placez le compte (de quel numéro d'objet il s'agit) dans le int. Dans la dernière structure de la liste, mettez une valeur de zéro dans le pointeur afin d'indiquer que c'est la fin. Écrivez une seconde fonction qui prend en argument la tête de votre liste, et qui se déplace jusqu'à la fin en affichant la valeur du pointeur et la valeur du int pour chaque nœud de la chaine.
26. Répétez l'exercice 24, mais placez les fonctions à l'intérieur d'une structure au lieu d'avoir des structures « brutes » et des fonctions séparées.