C++ – Méthodes et modalités de passage de paramètres

Ce document présume que, sur le plan du vocabulaire, vous savez ce qu'est une classe, une instance d'une classe, de même que ce que sont les constructeur et les destructeurs. Notez aussi que j'utiliserai des struct et des class selon les circonstances, privilégiant struct quand tous les membres sont publics et class dans les autres cas.

Bref survol des bases de l'encapsulation

Le principe d'encapsulation consiste à contrôler l'accès aux données membres, ou attributs, d'un objet de manière à lui permettre de garantir son intégrité. On énoncera ce principe comme suit : l'objet est responsable de son intégrité, et ce du début à la fin de son existence. Une forme équivalente serait d'exprimer que l'encapsulation signifie que l'objet garantit le respect de ses propres invariants.

Ce principe est en partie soutenu en C++ par la notion de membres privés, protégés et publics (qualifications private, protected et public, respectivement). L'accès aux attributs y est généralement restreint et contrôlé par un passage à travers des fonctions membres de l'objet, ou méthodes, et certaines méthodes sont exposées au grand public alors que d'autres auront des restrictions plus strictes d'accès.

Certaines méthodes serviront au contrôle d'accès primitif en lecture aux attributs de l'objet – on dira d'elles qu'elles sont les accesseurs des attributs. En contrepartie, les méthodes donnant un accès primitif en écriture aux attributs seront nommées mutateurs. Certains préfixent les accesseurs de mots reconnaissables comme Get ou de get (il n'est pas rare qu'on parle de getters, informellement), et les mutateurs de Set ou de set (il n'est pas rare qu'on parle de setters, informellement), mais cette pratique n'est pas universelle. En pratique, les mutateurs devraient être plus rares que les accesseurs, et rien n'oblige à associer ou accesseur ou un mutateur à un état – réfléchissez avant d'agir.

Les méthodes donnant un accès primitif aux données devront normalement être écrites de manière très optimisée, du fait que ces méthodes se veulent fondamentales et sont vouées à un usage fréquent. Dans certains langages, dont C++ et C#, il est possible de faire en sorte que ces accès soient faits à coût zéro (ou presque, dans le cas de C#). Maintenir une barrière entre l'utilisation faite d'un objet par le code client et sa représentation interne renforce le caractère générique d'une classe, ce qui la rend plus réutilisable et lui permet de mieux survivre au passage du temps.

Dans l'exemple ci-dessous, les attributs (privés) d'une instance de la classe (très simple) Eleve sont nom_ et age_. Une instance classe Eleve permet de consulter son nom et son âge par les accesseurs nom() et age() et n'offre pas de mutateurs pour les modifier.

#ifndef ELEVE_H
#define ELEVE_H
#include <string>
#include <string_view>
class Eleve {
   std::string nom_;
   unsigned short age_;
public:
   Eleve(std::string_view nom, unsigned short age) : nom_{ nom }, age_{ age } {
   }
   string nom() const {
      return nom_;
   }
   unsigned short age() const noexcept {
      return age_;
   }
};
#endif

Méthodes inline

Définir certaines méthodes – dans l'exemple de la classe Eleve ci-dessus, ce sont même toutes les méthodes – à même le corps de la classe permet au compilateur de générer inline les appels vers celles-ci.

Ceci a pour effet de remplacer (après validation des paramètres) l'appel du sous-programme par sa définition, et améliore la vitesse d'exécution. Le coût (en taille) de cette stratégie est minime dans la mesure où les fonctions en question sont très petites (une ou deux lignes, idéalement).

L'alternative est de séparer la déclaration d'une méthode de sa définition :

#ifndef ELEVE_H
#define ELEVE_H
#include <string>
#include <string_view>
class Eleve {
   std::string nom_;
   unsigned short age_;
public:
   Eleve(std::string_view, unsigned short);
   string nom() const;
   unsigned short age() const noexcept;
};
#endif

#include "Eleve.h"
#include <string>
using std::string;
using std::string_view;
Eleve::Eleve(string_view nom, unsigned short age) : nom_{ nom }, age_{ age } {
}
string Eleve::nom() const {
   return nom_;
}
unsigned short Eleve::age() const noexcept {
   return age_;
}
};

Ceci réduit la complexité des fichiers et sépare clairement les éléments clés d'une classe, mais a pour effet que l'appel par le code client d'une méthode d'une instance de la classe Eleve devra être résolu en appel de fonction à part entière, ce qui peut entraîner des coûts.

L'inlining peut grossir un programme et en ralentir l'exécution si on y a recours de manière abusive ou impropre, et peut en réduire la taille et l'accélérer si on s'en sert convenablement. Tout est question de doigté.

Paramètres const

string illegal_a(const string &s) {
   // illégal: s est const!
   s = s + "Ceci est illégal";
   return s;
}
string legal_a(const string &s) {
   // ok, ne modifie pas s
   return s + "Ceci est légal";
}
int illegal_b(const int i) {
   // illégal: i est const!
   i = i + 2;
   return i;
}
int legal_b(const int i) {
   // ok, ne modifie pas i
   return i + 2;
}

Paramètres passés par référence

Passer un paramètre par référence est utile pour plusieurs raisons. L'une d'entre elles est son impact sur la vitesse d'un programme.

En effet, le passage de paramètre par référence fait en sorte que seule l'adresse de l'objet original soit passée lors de l'appel (pas besoin d'empiler une copie du paramètre sur la pile d'exécution). Ainsi, on accélère grandement les appels de sous-programmes auxquels on passe des objets arbitrairement complexes (comme le sont, au fond, tous les objets).

Essayez, avec les procédures suivantes, d'appeler lent() avec une variable (pas une constante) de type std::string contenant un texte relativement long, et d'appeler rapide() avec la même chaîne de caractères. Faites-le pour une chaîne de 100K caractères, et effectuez 1000K appels, pour voir.

#include <string>
#include <chrono>
#include <iostream>
#include <utility>
using namespace std;
using namespace std::chrono;
template <class F, class ... Args>
   auto test(F f, Args &&... args) {
      auto pre = high_resolution_clock::now();
      auto res = f(std::forward<Args>(args)...);
      auto post = high_resolution_clock::now();
      return pair{ res, post - pre };
   }
bool lent(string s) {
   string temp = s;
   return temp.back() == 'a';
}
bool rapide(const string &s) {
   string temp = s;
   return temp.back() == 'a';
}
string creer_chaine(char c) {
   cout << "Nb. caractères de la chaîne: ";
   if (string::size_type n; cin >> n)
      return string(n, c);
   return {};
}
int main() {
   auto gros_texte = creer_chaine('a');
   cout << "Nb. d'appels à faire: ";
   if(int ntests; cin >> ntests) {
      auto [r0, dt0] = test([&] {
         int n = 0;
         for (int i = 0; i < ntests; ++i)
            n += static_cast<int>(lent(gros_texte));
         return n;
      });
      cout << "Nb tours: " << ntests << ", taille chaîne: " << r0
           << ", temps: " << duration_cast<milliseconds>(dt0).count() << " ms."
           << endl;
      auto [r1, dt1] = test([&] {
         int n = 0;
         for (int i = 0; i < ntests; ++i)
            n += static_cast<int>(rapide(gros_texte));
         return n;
      });
      cout << "Nb tours: " << ntests << ", taille chaîne: " << r1
           << ", temps: " << duration_cast<milliseconds>(dt1).count() << " ms."
           << endl;
   }
}

Au bureau, cela donne ce qui suit. Le premier temps est pour lent(), le second est pour rapide()) :

Nb. caractères de la chaîne: 1000
Nb. d'appels à faire: 10000000
Nb tours: 10000000, taille chaîne: 10000000, temps: 1865 ms.
Nb tours: 10000000, taille chaîne: 10000000, temps: 997 ms.

Paramètres passés en références-sur-const

// Paramètre passé par valeur : le paramètre original est protégé
void p0(string);
// Paramètre passé par référence : peut modifier le param. original
void p1(string&);
// Paramètre passé par référence, mais const : le paramètre
// original est protégé, mais ça va vite!
void p2(const string&);
// Quelques exemples d'appels valides et invalides
int main() {
   const string CONSTANTE = "Constante";
   string variable = "Variable";
   p0(variable);  // légal
   p0(CONSTANTE); // légal
   p1(variable);  // légal
   // p1(CONSTANTE); // illégal : passage par référence; la constante pourrait être modifiée par le sous-programme!
   p2(variable);  // légal
   p2(CONSTANTE); // légal : pasage par référence-vers-const; aucun risque.
}

void f(const int i) {
   i = 3; // boum!
}

void danger(int&);
void g(const int i) {
   danger(i); // boum!
}

struct X {
   void danger(); // n'est pas const
};
void h(const X &x) {
   x.danger(); // ne compile pas
}

class X {
   int i;
public:
   int f0() const { // légal
      return i;
   }
   int& f1() const { // illégal
      return i;
   }
   const int& f2() const { // légal
      return i;
   }
   int* f3() const { // illégal
      return &i;
   }
   const int* f4() const { // légal
      return &i;
   }
};

Lectures complémentaires

Quelques liens pour enrichir le propos.

• En 2016, Jonathan Müller montre comment exprimer un paramètre sortant de manière descriptive en C++ : https://foonathan.net/2016/10/output-parameter/
• En 2020, Raymond Chen rappelle que, si vous comptez préserver le paramètre passé à une fonction, il n'est pas utile d'écrire une surcharge acceptant const T& et une autre acceptant T&& puisque le passage par valeur fera très bien le travail : https://devblogs.microsoft.com/oldnewthing/20200219-00/?p=103452