Discussion :

[mchk0123]

Bonjour à tous,

Voilà je développe une bibliothèque dans laquelle j'ai une hiérarchie de classe héritante toutes de la class de base "Base".

Pour abstraire un maximum de code, j'hérite également d'une classe template spécialisée "Check" qui implémente une méthode de vérification de certaines conditions (sorte de assert ou de programmation par contrat).

La spécialisation à lieu selon un paramètre de template de type int (en réalité un enum) indiquant quel type de vérification doit être fait.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <iostream>
 
using namespace std;
 
class Base {
  public:
    Base() : ptr(NULL), size(0), saved_index(0) {
    }
    void do_check() const {
      if (!check())
        cerr << "<< ERROR : check failed ! >>" << endl;
    }
  protected:
    virtual bool check() const = 0;
  protected:
    void *ptr;
    size_t size, saved_index;
};
 
typedef enum { ct_none, ct_no_nulls, ct_index_bounds, ct_memory_leaks } check_type_t;
 
template<int check_type>
class Check : public Base {
  protected:
    bool check() const;
};
 
template<>
class Check<ct_none> : public Base {
  protected:
    bool check() const {
      return true;
    }
};
 
template<>
class Check<ct_no_nulls> : public Base {
  protected:
    bool check() const {
      return ptr != NULL;
    }
};
 
template<>
class Check<ct_index_bounds> : public Base {
  protected:
    bool check() const {
      return saved_index < size;
    }
};
 
template<>
class Check<ct_memory_leaks> : public Base {
  protected:
    bool check() const {
      return ptr == NULL;
    }
};
 
class Child1 : public Check<ct_none> {
};
 
class Child2 : public Check<ct_no_nulls> {
};
 
class Child3 : public Check<ct_index_bounds>, Check<ct_memory_leaks> {
};
 
int main() {
  Child1 c1;
  Child2 c2;
  Child3 c3;
 
  c1.do_check();
  c2.do_check();
  //c3.do_check(); // là ça plante à la compilation
 
  return 0;
}

Cependant certaines classe héritées, doivent réaliser plusieurs vérifications, donc comment s'en sortir avec les templates ? La vraiment je ne vois pas ...

[loufoque]

Pour abstraire un maximum de code, j'hérite également d'une classe template spécialisée "Check" qui implémente une méthode de vérification de certaines conditions (sorte de assert ou de programmation par contrat).

Tu peux peut-être regarder du côté de boost.concept_check.
Sinon tu peux aussi prendre un compilateur qui implémente les Concepts de C++0x.

[PierroElMito]

A mon avis, il vaut mieux utiliser l'aggrégation que l'héritage pour faire tes checks.

[XtremDev]

Tu n'a qu'a utiliser les différents bits de ton int check pour définir les types de vérifications à effectuer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
typedef enum {
ct_none = 0x00,
ct_no_nulls = 0x01,
ct_index_bounds  = 0x02,
ct_memory_leaks  = 0x04,
//etc...
} check_type_t
 
 
template<int check_type>
class Check : public Base {
  protected:
    bool check() const
    {
	bool bCheckResult = true;
 
	if(check_type & ct_no_nulls)
	{
		bCheckResult = bCheckResult && (ptr != NULL);
	}
 
	if(check_type & ct_index_bounds)
	{
		bCheckResult = bCheckResult && (saved_index < size);
	}
 
 
	if(check_type & ct_memory_leaks)
	{
		bCheckResult = bCheckResult && (ptr == NULL);
	}
 
 
	if(check_type & ct_index_bounds)
	{
		bCheckResult = bCheckResult && (saved_index < size);
	}
 
	return bCheckResult;
    }
};

du coup Child3 devient

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
class Child3 : public Check<ct_index_bounds|ct_memory_leaks> {
};

J'ai pas essayé mais ça devrait rouler...

[mchk0123]

pas essayé mais ça devrait rouler...

Merci XtremDev, et oui non seulement ça fonctionne parfaitement, mais en plus la série de "if" est évaluée à la compilation, ce qui fait que j'ai n fonction "check()" spécialisée contenant chacune uniquement le code nécessaire.

Comme quoi, dès fois la solution la plus simple est la meilleure.

Pendant que j'y suis, pour rester dans la simplicité, je me demandais si je ne pouvais pas retransformer un peu la collaboration entre classes. J'hésite entre plusieurs alternatives :

1. Utiliser une fonction template au lieu d'une classe template "Check"
2. Faire de l'héritage multiple pour découpler "Check" de "Base" (Check n'hériterais donc plus directement de "Base")
3. Accéder à "Check" depuis "Base" via une délégation plutôt qu'un héritage

Je vois bien les avantages de chacune des solutions, par contre pour les inconvénients j'ai du mal en à imaginer les futurs blocages probables si je devais adopter telle ou telle solution.

[loufoque]

Sauf qu'il n'y en a pas actuellement (juste un proto, pas utilisable pour du vrai code de production).

C'est en effet en version alpha, c'est à dire que seulement partiellement implémenté.
Mais je ne vois pas trop en quoi ça pose problème pour la production, si ce n'est que la dernière version par exemple est basée sur une branche non stable de GCC.

[JolyLoic]

Sinon tu peux aussi prendre un compilateur qui implémente les Concepts de C++0x.

Sauf qu'il n'y en a pas actuellement (juste un proto, pas utilisable pour du vrai code de production). De toute façon, la syntaxe elle même n'est pas encore fixé (j'écris justement depuis une discussion au sujet d'un point de syntaxe, et il y a aussi eu d'autres détails de ce genre hier). C'est en cours de stabilisation, mais ce n'est pas fini.