Bug indétectable via printf() / cout

Bonjour à tous,

Je travaille dans une équipe de personnes pour lesquels le débugger
n'est pas l'outil qui tombe sous le sens lorsqu'il s'agit de trouver
les bugs des outils qu'ils ont développé.

Afin de les sensibiliser, je recherche un exemple de bug difficile
(voir impossible) a détecter via des printf()/cout qui n'afficheraient
que les contenus des variables. (Je me rends bien compte qu'on doit
pouvoir tout débugger avec printf()/cout, mais il faut parfois
afficher les adresses des variable (en plus de leur valeur), voir
parfois la mémoire à certains endroits.)

Je voudrais construire un exemple simple (notions de C++ pas trop
compliquées) et court (un seul fichier, 100 lignes max) pour qu'on
puisse l'étudier en un quart d'heure, mais le débugger en un temps
presque infini sans débugger.

Il est possible que l'exemple, puisqu'il y a un bug, dépende de la
plateforme mais c'est un peu inévitable.

L'idéal serait que le plantage ait lieu bien après le bugça rajout=
e
du piment. Bref, vous voyez l'idée quoi

J'avais plusieurs pistes d'exploitation de bug:

Piste 1:
Boucle for décroissante sur un entier non signé : for(size_t i = N;
0<= i; i--)

Piste 2:
comparaison de double : double x; ; x == 0.0

Piste 3:
retour de malloc() non testé

Piste 4:
caractère de fin de ligne non testé (\0)

Mais jusque là, je crains qu'il ne soit trop facile de détecter le
bug

J'ai donc ensuite pensé aux références. Mais ce code est encore un pe=
u
trop voyant. Dans le main(), on peut facilement se demander pourquoi
f1 et f2 sont des références, ce qui met directement la puce à
l'oreille. Peut être trouvez vous ce code bien trop compliqué, ou
auriez vous en tête un manière de "l'améliorer" :-)

A bon entendeur salut.

AG.




#include <iostream>

using namespace std;

#define BUFFER_LENGTH 10

template<int N, class T>
class fifo_circular
{
private:
T * position;
size_t pos_offset;
T buffer[N];

public:
fifo_circular() { pos_offset = N-1; position = buffer + pos_offset;
for(int i=0;i<N;i++) buffer[i]=T(0);};

T step(T &input)
{
*position = input;

if(pos_offset>0) // ici il y aurait peut être moyen de glisser le
bug de la piste 1
pos_offset--;
else
pos_offset = N-1;

position = buffer + pos_offset;
return *position;
};

template<int M, class U> friend ostream & operator<<(ostream & o,
const fifo_circular<M,U> &f);
};

template<int N, class T>
fifo_circular<N,T> & Init(T & value)
{
fifo_circular<N,T> & f = fifo_circular<N,T>(); // hé hé hé

for(size_t i = 0; i < N; i++)
f.step(value);
return f;
}

template<int M, class U>
ostream & operator<<(ostream & o, const fifo_circular<M,U> &f)
{
for(size_t i = 0; i < M; i++)
o << f.buffer[i] << " ";
return o;
}

int main(int argc, char * argv[])
{
int a = 1;
fifo_circular<5,int> & f1 = Init<5,int>(a); // ici, c'est un peu trop
voyant. On se demande pourquoi f1 est déclaré en tant que
référence
a = 2;
fifo_circular<5,int> & f2 = Init<5,int>(a);

cout << "fifo f1: " << f1 << "";
cout << "fifo f2: " << f2 << "";

return 0;
}