C++ Exercises from Claude Delannoy's 3rd Edition

Introduction au langage C++ et aux concepts de Programmation Orientée Objet

Principes Fondamentaux du C++

• Syntaxe de base: Un programme C++ minimal inclut `iostream` pour les entrées-sorties et utilise l'espace de noms `std`.

  #include <iostream>
  using namespace std ;
  main()     // en-tête
  { ... // corps du programme
  }

• Déclarations de variables: Toutes les variables doivent être déclarées avec leur type, et peuvent être initialisées.

  int i ;   // i est une variable de type int nommée i
  float x = 5.25 ;  // x est une variable de type float nommée x
  const int NFOIS = 5; // NFOIS est une variable constante

• Entrées/Sorties Standard:
  • Affichage: Le flot `cout` est utilisé pour afficher des informations.

    cout << n << 2*p ; // affiche les valeurs de n et de 2*p sur l'écran

  • Lecture: Le flot `cin` est utilisé pour lire des informations du clavier.

    cin >> x >> y ; // lit deux valeurs au clavier et les affecte à x et à y

Types de base, Opérateurs et Expressions

Types de base

• Types entiers: `short int`, `int`, `long int`. Également des versions non signées: `unsigned short int`, `unsigned int`, `unsigned long int` pour la manipulation de motifs binaires. Des constantes entières peuvent être en hexadécimal (ex: `0xF54B`) ou octal (ex: `014`).
• Types flottants: `float`, `double`, `long double`. Leur précision et domaine dépendent de l'implémentation.
• Types caractères: `signed char`, `unsigned char`, `char`. Les constantes caractères sont entre apostrophes (ex: `'A'`). Des caractères spéciaux utilisent le préfixe `\` (ex: `'\n'`, `'\x41'`).
• Type booléen: `bool` avec les constantes `true` et `false`.

Opérateurs

Conversions Implicites

• Ajustement de type: `int -> long -> float -> double -> long double` ou `unsigned int -> unsigned long -> float -> double -> long double`.
• Promotions numériques: `char`, `bool`, `short` sont convertis en `int`.

Opérateurs Logiques (`&&`, `||`, `!`)

Opérateurs d'Affectation

valeur = 2*n-1 ? a : b ;
// affecte à "valeur" la valeur de "a" si (2*n-1) est non nul, sinon la valeur de "b".

Opérateurs d'Incrémentation et Décrémentation (`++`, `--`)

• Préfixe (`++n`): Modifie la valeur puis la fournit.
• Postfixe (`n++`): Fournit la valeur puis la modifie.

Opérateur `cast`

(double) n / p // Convertit n en double avant la division
// équivalent à static_cast<double>(n/p)

Instructions de contrôle

Instructions Conditionnelles

• `if-else`:

  if (expression) instruction_1
  else instruction_2

  Un `else` se rapporte toujours au dernier `if` sans `else` attribué.
• `switch`: Évalue une expression entière et exécute le bloc d'instructions correspondant à une étiquette `case`.

  switch (expression) { bloc_d_instructions }

  • Les valeurs `case` doivent être des expressions `constantes`.
  • `break` permet de sortir du bloc `switch`.
  • `default` est exécuté si aucune valeur `case` ne correspond.

Instructions Itératives (Boucles)

• `do-while`: Exécute l'instruction au moins une fois, puis répète tant que l'expression est vraie.

  do instruction while (expression) ;

• `while`: Répète l'instruction tant que l'expression est vraie.

  while (expression) instruction

• `for`: Pour des boucles avec une initialisation, une condition et une incrémentation.

  for ([expression_déclaration_1] ; [expression_2] ; [expression_3]) instruction

  Équivalent à:

  { expression_déclaration_1 ;
  while (expression_2) { instruction ;
  expression_3 ;
  }

  Les crochets indiquent que le contenu est facultatif.

Instructions de Saut

• `break`: Interrompt l'exécution de la boucle ou du `switch` le plus interne.
• `continue`: Passe au tour de boucle suivant.
• `goto`: Permet un branchement inconditionnel à une étiquette de programme.

Fonctions en C++

Définition et Déclaration

• Définition: Corps de la fonction et sa signature.

  float fexple(float x, int b, int c)  // en-tête
  {  // corps de la fonction
  }

• Déclaration (Prototype): Spécifie la signature de la fonction avant son utilisation.

  float fepxle(float, int, int) ; // Déclaration (prototype)

  La déclaration peut être omise si la définition est rencontrée avant l'appel.

Transmission des Arguments

• Par valeur (par défaut): Une copie de l'argument est passée à la fonction. Les modifications n'affectent pas l'original.
• Par référence (`&`): Le type de l'argument est suivi de `&`. Les modifications dans la fonction affectent l'argument effectif. L'argument doit être une `lvalue` du même type. Si `const` est utilisé, une copie temporaire peut être créée.

Valeur de Retour

• `return`: Termine l'exécution de la fonction et retourne une valeur.
• `void`: Indique qu'une fonction ne retourne aucune valeur.
• Liste d'arguments vide: `fSansArguments ()` pour une fonction sans arguments.

Valeurs par Défaut pour les Arguments

float fct (char, int = 10, float = 0.0);

Portée et Classe d'Allocation des Variables

• Variables globales: Déclarées en dehors de toute fonction; portée au-delà de leur déclaration dans le fichier. Classe d'allocation statique (emplacement mémoire fixe).
• Variables locales: Déclarées dans une fonction (ou un bloc); portée limitée à celle-ci. Classe d'allocation automatique (allouées à l'entrée, libérées à la sortie).
• Variables `static` locales: Locales mais de classe d'allocation statique. Initialisées une seule fois à zéro par défaut.

Surdéfinition des Fonctions (Surcharge)

Fonctions `inline`

• Déclarées avec le mot-clé `inline`.
• La définition doit être présente lors de la déclaration.

Tableaux, Pointeurs et Chaînes de caractères à la C

Tableaux à un indice

float t [10] ; // Déclare un tableau de 10 floats

• Un élément de tableau est une `lvalue`.
• L'indice peut être n'importe quelle expression arithmétique de type entier.
• La taille du tableau doit être une expression constante.

Tableaux à plusieurs indices

Initialisation des tableaux

• Les tableaux de classe statique sont initialisés à zéro par défaut.
• Les tableaux de classe automatique ne sont pas initialisés par défaut.
• L'initialisation pendant la déclaration est possible:

  int t1[5] = { 10, 20, 5, 0, 3 } ;
  int t2 [5] = { 10, 20 } ; // Les éléments restants sont à zéro

• Pour les tableaux multidimensionnels, on peut utiliser des listes imbriquées ou une liste plate:

  int tab [3] [4] = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9,10,11,12 } } ;
  int tab [3] [4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 } ;

Pointeurs

int * adi ; // pointeur vers un entier
float * adf ; // pointeur vers un flottant

• Opérateur `&`: Retourne l'adresse d'une variable (ex: `adi = &n;`).
• Opérateur `*`: Déréférence un pointeur, accédant à la valeur stockée à l'adresse (ex: `int p = *adi;`).
• Pointeur générique: `void *` peut pointer vers n'importe quel type de données.

Arithmétique des pointeurs

adi++; // adi pointe sur l'entier suivant
adi -= 10; // adi pointe 10 entiers avant

Relations entre tableaux et pointeurs

• Un nom de tableau est une constante pointeur vers son premier élément.

  int t[10];
  t+1 est équivalent à &t[1];
  t[i] est équivalent à *(t+i).

• Lorsqu'un tableau est passé en argument à une fonction, c'est son adresse qui est transmise.
• Déclarations équivalentes pour un argument de fonction:

  void fct (int t[10])
  void fct (int t[])
  void fct (int * t)

Allocation dynamique avec `new` et `delete`

new type [n] // Alloue n éléments de 'type', retourne un pointeur
delete adresse // Libère la mémoire allouée par new

Pointeurs sur fonctions

int (* adf) (double, int) ; // adf est un pointeur sur une fonction

Chaînes de caractères à la C

char ch[20] = "bonjour" ;
// Équivalent à:
char ch[20] = { 'b', 'o', 'n', 'j', 'o', 'u', 'r', '\0' } ;

Arguments de la fonction `main`

main (int nbarg, char * argv[])

Structures

Définition d'une structure

struct enreg {
    int numero ;
    int qte ;
    float prix ;
};

• Le type `enreg` est maintenant défini.
• Des variables peuvent être déclarées avec ce type : `enreg art1, art2 ;`.

Accès aux membres d'une structure

art1.numero ; // Accède au champ 'numero' de la structure 'art1'
art2.prix ;   // Accède au champ 'prix' de la structure 'art2'

Affectation et initialisation des structures

• Une structure peut être affectée à une autre structure de même type (`art1 = art2;`).
• Initialisation lors de la déclaration :

  enreg art1 = { 100, 285, 200 } ;

• Les structures de classe statique initialisent leurs champs à zéro par défaut. Celles de classe automatique ne sont pas initialisées.

Transition du C au C++

Incompatibilités et Spécificités

• Déclaration de fonctions: En C++, toutes les fonctions doivent être déclarées via un prototype avant leur utilisation. Le C permettait des déclarations implicites ou incomplètes.
• Fonctions sans arguments: En C++, utilisez `float fct()`. En C, `float fct(void)` était également courant.
• Fonctions sans valeur de retour: En C++, utilisez `void` explicitement (ex: `void fct(int, double)`). En C, `void` était facultatif.
• Variables `const` globales: En C++, elles ont une portée limitée au fichier. En C, elles pouvaient être `extern`. De plus, les `const` C++ peuvent être utilisées dans des expressions constantes (contrairement au C qui nécessitait `#define`).
• `void *`: En C++, un `void *` ne peut pas être converti implicitement en un autre type de pointeur lors d'une affectation (un `cast` explicite est requis).

Nouvelles fonctionnalités C++

• Entrées-sorties avec `iostream`: `cout` et `cin` remplacent `printf` et `scanf`, offrant une gestion des types plus souple.

  cout << expression_1 << expression_2 ;
  cin >> lvalue_1 >> lvalue_2 ;

  Les opérateurs `<<` et `>>` gèrent automatiquement les conversions de type.
• Commentaires de fin de ligne: `//` commente le reste de la ligne.
• Déclarations de variables dynamiques: Les déclarations ne sont plus limitées au début des blocs ou fonctions.

  for (int i=0 ; ... ; ...) { ... } // Portée de i limitée à la boucle

• Transmission par référence: Via l'opérateur `&`. Permet de modifier l'argument original.

  void fonction(int &arg) ;

• Valeurs par défaut pour les arguments: Définies dans le prototype de la fonction.

  float fct (char, int = 10, float = 0.0);

• Surdéfinition de fonctions: Permet à plusieurs fonctions de porter le même nom si leur signature diffère, avec résolution par le compilateur.
• Opérateurs `new` et `delete`: Remplacent `malloc`, `calloc` et `free` pour l'allocation et la désallocation dynamique.

  new type [n] ; // Alloue n éléments
  delete adresse ; // Libère la mémoire

• Fonctions `inline`: Mot-clé `inline` pour optimiser les appels de fonctions.

Notions de Classe, Constructeur et Destructeur

Concept de Classe

Déclaration d'une Classe

class point
{
private:
    int x;
    int y;
public:
    void initialise(int, int);
    void deplace(int, int);
    void affiche();
};

Définition des Fonctions Membre

void point::initialise(int abs, int ord)
{
    x = abs; y = ord;
}

Déclaration et Utilisation d'Objets

point a, b; // Déclare deux objets 'a' et 'b' de type 'point'
a.initialise(5, 2); // Appelle une fonction membre

Constructeurs et Destructeurs

• Constructeur: Fonction membre portant le même nom que la classe. Appelée après l'allocation mémoire pour un objet, initialise ses membres. Ne retourne pas de valeur.
• Destructeur: Fonction membre précédée d'un tilde (`~`) et portant le nom de la classe. Appelée avant la libération de la mémoire de l'objet. Ne prend pas d'arguments et ne retourne pas de valeur.

Membres `static`

static int nb_pts = 0; // Initialisation du membre statique

Organisation des fichiers pour les classes

• Fichier en-tête (`.h`): Contient la déclaration de la classe.
• Fichier source (`.cpp`): Contient la définition des fonctions membre.

Propriétés des Fonctions Membre

Fonctions Membre `inline`

Arguments de type classe

Valeurs de retour de type classe

Pointeur `this`

Fonctions Membre `static`

Objets `const` et fonctions membre `const`

Construction, destruction et initialisation des objets

Quand le constructeur/destructeur est appelé

• Constructeur: Après l'allocation mémoire.
• Destructeur: Avant la libération mémoire.

Objets automatiques et statiques

• Automatiques: Créés via une déclaration dans une fonction ou un bloc. Durée de vie limitée au bloc.
• Statiques: Créés en dehors de toute fonction ou avec le mot-clé `static` dans une fonction/bloc. Créés avant `main`, détruits après `main`.

Objets temporaires

Objets dynamiques

point * adp = new point(2.5, 5.32);
delete adp;

Membres de type classe

pointcol(float abs, float ord, int coul) : p(abs, ord) { /* ... */ }

Initialisation par recopie

Tableaux d'objets

point courbe[20]; // 20 objets 'point'
point * adcourbe = new point[20]; // Allocation dynamique

Fonctions Amies

Déclaration d'une fonction amie

class A {
    friend void fct(---) ; // fct peut accéder aux membres privés de A
};

Fonction membre d'une autre classe comme amie

class A {
    friend void B::fct(---) ; // B::fct peut accéder aux membres privés de A
};

Classe entière comme amie

class A {
    friend class B ; // Toutes les fonctions de B peuvent accéder aux membres privés de A
};

Surdéfinition d'Opérateurs

Principe

Définition

• Fonction indépendante (généralement amie): `operator op(a, b)`
• Fonction membre: `a.operator op(b)` (pour opérateur binaire)

Règles

• Ne peut surdéfinir que les opérateurs existants, en conservant leur arité (unaire, binaire).
• Doit toujours avoir au moins un opérande de type classe.
• Les opérateurs `[]`, `()`, `->`, `new` et `delete` doivent être des fonctions membre.
• Les opérateurs `=` et `&` ont une signification par défaut qui peut être surdéfinie.

Tableau des opérateurs surdéfinissables (par priorité décroissante)

Conversions de Type Définies par l'Utilisateur (CDU)

Types de fonctions pour les CDU

• Constructeurs à un argument: Convertit le type de l'argument en le type de la classe. Peut être `explicit` pour interdire les conversions implicites.
• Opérateurs de cast: Permettent de convertir la classe en un autre type.

  operator x () ; // Convertit la classe en type 'x'

  Le type de retour n'est pas spécifié dans le prototype.

Règles d'utilisation des CDU

• Les conversions ne sont mises en œuvre que si nécessaire.
• Une seule CDU peut intervenir dans une chaîne de conversions.
• Pas d'ambiguïté (plusieurs chaînes de conversions vers le même type).

La Technique de l'Héritage

Dérivation de classes

class B : public A // ou private A, ou protected A
{
    // Membres supplémentaires ou redéfinitions
}

Statut des membres

• `private`: Inaccessible de l'extérieur ou des classes dérivées.
• `protected`: Inaccessible de l'extérieur, mais accessible aux fonctions membre des classes dérivées.
• `public`: Accessible de l'extérieur et des classes dérivées.

Types de dérivation

• `public`: Les membres de la classe de base conservent leur statut. Le plus courant.
• `private`: Tous les membres de la classe de base deviennent `private` dans la classe dérivée.
• `protected`: Les membres `public` de la classe de base deviennent `protected` dans la classe dérivée.

Constructeurs et Destructeurs dans l'Héritage

• Le constructeur de la classe dérivée doit appeler un constructeur de la classe de base (sauf si la classe de base n'a pas de constructeur ou en a un sans arguments).

  B(int x, int y, char coul) : A(x, y) { /* ... */ }

• Les destructeurs sont appelés dans l'ordre inverse de la construction.

Initialisation par recopie avec héritage

• Appel du constructeur par recopie de la classe de base.
• Initialisation des membres propres à la classe dérivée.

Compatibilité entre pointeurs et objets de classes liées par héritage

• Un objet de classe dérivée peut être affecté à un objet de classe de base (`a = b`).
• Un pointeur sur une classe dérivée peut être affecté à un pointeur sur une classe de base (`ada = adb`).
• Les inversions sont illégales sans `cast` explicite.

L'Héritage Multiple

Principe

class C : public B, public A { /* ... */ };

Accès aux membres

Constructeurs et Destructeurs

• Les constructeurs des classes de base sont appelés dans l'ordre de leur déclaration dans la classe dérivée.
• Les destructeurs sont appelés dans l'ordre inverse.

Héritage virtuel

class B : public virtual A { /* ... */ };
class C : public virtual A { /* ... */ };
class D : public B, public C { /* ... */ };

Les Fonctions Virtuelles

Typage statique vs. dynamique

• Typage statique: La fonction appelée est déterminée à la compilation, basée sur le type déclaré du pointeur.
• Typage dynamique: Avec les fonctions `virtual`, la fonction appelée est déterminée à l'exécution, basée sur le type réel de l'objet pointé.

Déclaration d'une fonction virtuelle

class A {
public:
    virtual void fct();
};

Règles des fonctions virtuelles

• `virtual` n'est utilisé qu'une fois (dans la classe de base).
• Une fonction virtuelle peut ne pas être redéfinie dans les classes dérivées.
• Un constructeur ne peut pas être virtuel, un destructeur le peut (`virtual ~Classe();`).
• Le mécanisme de ligature dynamique est limité à une hiérarchie de classes.

Fonctions virtuelles pures

virtual void affiche() = 0; // Fonction virtuelle pure

Les Flots d'Entrée et de Sortie

Principes des flots

• Un flot d'entrée utilise `istream` (ex: `cin`).
• Un flot de sortie utilise `ostream` (ex: `cout`).

Flot de Sortie (`ostream`)

• Opérateur `<<`: Surdéfini pour divers types de données (int, float, char*, etc.).
• Fonctions membre:
  • `put(char c)`: Transmet un caractère.
  • `write(void *adr, int long)`: Envoie un bloc de caractères.

Flot d'Entrée (`istream`)

• Opérateur `>>`: Surdéfini pour des types de base (sauf pointeurs génériques).
• Fonctions membre:
  • `get(char &c)` / `get()`: Extrait un caractère.
  • `read(void *adr, int taille)`: Lit un bloc de caractères.

Flot d'Entrée/Sortie (`fstream`)

Statut d'erreur du flot

• `eofbit`: Fin de fichier.
• `failbit`: La prochaine opération échouera.
• `badbit`: Flot dans un état irrécupérable.
• `goodbit`: Pas d'erreur.

Surdéfinition de `<<` et `>>` pour les classes

ostream &operator<<(ostream &output, YourClass &obj) { /* ... */ return output; }
istream &operator>>(istream &input, YourClass &obj) { /* ... */ return input; }

Formatage des flots

• Bits du mot d'état: `ios::dec`, `ios::oct`, `ios::hex` (base), `ios::showbase`, `ios::showpoint`, `ios::scientific`, `ios::fixed`.
• Manipulateurs non paramétriques: `dec`, `hex`, `oct`, `endl`, `ends`.
• Manipulateurs paramétriques: `setbase(int)`, `setprecision(int)`, `setw(int)`. Nécessite `iomanip`.

Fichiers (`fstream`)

• `ofstream` pour la sortie vers un fichier.

  ofstream flot("fichier.txt", ios::out);

• `ifstream` pour l'entrée depuis un fichier.

  ifstream flot("fichier.txt", ios::in);

• Fonctions `seekp()`/`seekg()` pour positionner le pointeur de fichier.
• `close()` pour fermer le fichier.

Les Patrons de Fonctions

Principe

template  T carre(T a) { return a * a; }

template  int compte(T * tab, int n) { /* ... */ }

template  class gene { /* ... */ };

template  gene::gene(...) { /* ... */ }

gene c1; // T = int, N = 5

// Spécialisation complète
template<> class tableau { /* ... */ };

// Spécialisation partielle
template class point { /* ... */ };

void maFonction() throw(int, MonException) { /* ... */ }