Un type Noisy

La classe Noisy ci-dessous est une technique recommandée par Stephan T. Lavavej pour détecter les opérations de la Sainte-Trinité dans un programme générique. Utiliser un Noisy en tant que type T produit une trace de chacune de ces opérations.

Elle peut se présenter comme suit (Stephan T. Lavavej remplace les écritures à travers std::cout par des appels à puts(), ce qui réduit les dépendances dans le code) :

#include <iostream>
using namespace std;
struct Noisy {
   Noisy() { cout << "Noisy::Noisy()" << endl; }
   Noisy(const Noisy&) { cout << "Noisy::Noisy(const Noisy&)" << endl; }
   Noisy(Noisy&&) { cout << "Noisy::Noisy(Noisy&&)" << endl; }
   Noisy& operator=(const Noisy&) {
      cout << "Noisy::operator=(const Noisy&)" << endl; return *this;
   }
   Noisy& operator=(Noisy&&) {
      cout << "Noisy::operator=(Noisy&&)" << endl; return *this;
   }
   ~Noisy() { cout << "Noisy::~Noisy()" << endl; }
};

C'est un bon truc pour déboguer le code générique et comprendre les différences entre diverses écritures. Par exemple :

// ... classe Noisy (omise)...
template <class T>
   T f(T arg) {
      return arg;
   }
int main() {
   Noisy n;
   n = f(n);
}

// ... classe Noisy (omise)...
template <class T>
   T f() {
      return{};
   }
int main() {
   Noisy n;
   n = f<Noisy>();
}

// ... classe Noisy (omise)...
template <class T>
   T f(T arg) {
      return arg;
   }
int main() {
   Noisy n = f(Noisy{});
}

// ... classe Noisy (omise)...
template <class T>
   T f() {
      return{};
   }
int main() {
   Noisy n = f<Noisy>();
}

Noisy::Noisy()
Noisy::Noisy(const Noisy&)
Noisy::Noisy(Noisy&&)
Noisy::~Noisy()
Noisy::operator=(Noisy&&)
Noisy::~Noisy()
Noisy::~Noisy()

Noisy::Noisy()
Noisy::Noisy()
Noisy::operator=(Noisy&&)
Noisy::~Noisy()
Noisy::~Noisy()

Noisy::Noisy()
Noisy::Noisy(Noisy&&)
Noisy::~Noisy()
Noisy::~Noisy()

Noisy::Noisy()
Noisy::~Noisy()

C'est, en soi, instructif.