Série 10 : Templates

Buts

Cette série a pour but de vous faire pratiquer la programmation générique (templates).

Préliminaires :

Avant de commencer les exercices décrits dans cette série, créez le répertoire ~/Desktop/myfiles/cpp/serie22 et travaillez dans ce répertoire.

Exercice 0 : reprise de l'exemple du cours (templates, niveau 0)

Le but de cet exercice est de reprendre les exemples du cours relatifs aux templates (programmation générique).

Cliquez ici si vous souhaitez faire cet exercice.

Exercice 1 : chemin parcouru (niveau 3)

Exercice n°70 (page 185 et 379) de l'ouvrage C++ par la pratique.

Pour vous faire estimer le chemin parcouru depuis un semestre, je vous propose de reprendre l'exercice 3 de la série 7.

Cet exercice est niveau 3 car je vais vous demander d'utiliser plusieurs des concepts des plus avancés que nous avons vu, combinés : POO, programmation générique, surcharge d'opérateurs et exceptions.

Vous pouvez cependant essayer de faire cet exercice à votre niveau (par exemple sans programmation générique ou sans surcharge) en en suivant l'esprit : comment feriez vous maintenant un programme de manipulation de matrice.

(niveau 3) Créez un modèle de classe Matrice prennant un type abstrait en argument, et héritant de tableau dynamique de tableau dynamique (2 fois) sur ce type.

Ajoutez à ce modèle de classe les constructeurs et destructeur qui vous paraissent nécessaires.

Surchargez maintenant les opérateurs de multiplication (*, attention il est non commutatif pour les matrices ! ne vous trompez pas de sens), d'affichage (<<) et de lecture (>>) (ancien lire_matrice, cf ennoncé de la série 7, en gérant les erreurs par des exceptions, de sorte que le main suivant :

// ----------------------------------------------------------------------
Matrice<double> saisie_matrice() {
  cout << "Saisie d'une matrice :" << endl;
  cout << "  Nombre de lignes : ";
  unsigned int n;
  cin >> n;
  cout << "  Nombre de colonnes : ";
  unsigned int m;
  cin >> m;

  Matrice<double> M(n,m);
  cin >> M;

  return M;
}

// ----------------------------------------------------------------------
int main()
{
  Matrice<double> M1(saisie_matrice());
  Matrice<double> M2(saisie_matrice());
  Matrice<double> M;

  try {
    M = M1 * M2;
  }
  catch (Matrice<double>::error e) {
    switch (e) {
    case Matrice<double>::WRONG_SIZES:
      cerr << "Multiplication de matrices impossible !" << endl;
      break;
    }
  }

  cout << "Résultat :" << endl << M << endl;

  return 0;
}

puisse produire par exemple (inspiré de la série 6) :

Saisie d'une matrice :
  Nombre de lignes : 2
  Nombre de colonnes : 3
  Entrez la matrice :
1 2 3
4 5 6
Saisie d'une matrice :
  Nombre de lignes : 3
  Nombre de colonnes : 4
  Entrez la matrice :
1 2 3 4
5 6 7 8
9 0 1 2

Résultat :
38 14 20 26
83 38 53 68

Si vous êtes motivé(e)s, complétez la classe par des méthodes/opérateurs usuels : addition, soustraction, et si vous êtes vraiment très motivé(e) (et fort(e) en algèbre linéaire) (il est en train de devenir niveau 4 mon exercice !) par les méthodes determinant et inverse (lorsque cela à un sens), et l'opérateur division (multiplication à droite par l'inverse de l'opérande).

Projet

Pour faire la partie concernant le projet, voir ici.