Condition de check par spécialisation de templates

Version imprimable

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:

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 :? :question: ...

19/04/2007, 03h16
loufoque

Citation:

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.
19/04/2007, 10h15
PierroElMito

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

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

Code:

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:

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

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

19/04/2007, 11h02
JolyLoic

Citation:

Envoyé par loufoque

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.
20/04/2007, 14h46
mchk0123

Citation:

Envoyé par XtremDev

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.
20/04/2007, 16h07
loufoque

Citation:

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.
23/04/2007, 02h22
JolyLoic

Citation:

Envoyé par loufoque

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.

Ca pose un problème dans le sens où le code valide un jour risque fort de ne plus l'être le lendemain. Par exemple, suite à la réunion d'Oxford, la syntaxe pour un et entre deux concepts est redevenue '&&' et non ',', les parenthèses ont disparu, il n'y a plus de possibilité de ou entre concepts (mais je ne suis pas certain que cette possibilité ait été implémentée). Et ce n'est pas fini.

Bon pendant que j'y suis pour ceux que cela intêressent, j'ai amélioré mon programme :

Code:

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
#include <iostream>
 
using namespace std;
 
class Class {
  public:
    Base() : ptr(NULL), size(0), saved_index(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;
 
class CheckBase {
  public:
    void do_check() const {
      if (!check())
        cerr << "<< ERROR : check failed ! >>" << endl;
    }
  protected:
    virtual bool check() const = 0;
}
 
template<class T, int check_type>
class Check : public CheckBase {
};
 
template<int check_type>
class Check<Class, check_type> : public CheckBase {
  public:
    Check(Class *cls) : _cls(cls) {
    }
  protected:
    bool check() const {
	bool bCheckResult = true;
 
	if(check_type & ct_no_nulls)
	    bCheckResult = bCheckResult && (_cls->ptr != NULL);
	if(check_type & ct_index_bounds)
	    bCheckResult = bCheckResult && (_cls->saved_index < _cls->size);
	if(check_type & ct_memory_leaks)
	    bCheckResult = bCheckResult && (_cls->ptr == NULL);
	if(check_type & ct_index_bounds)
	    bCheckResult = bCheckResult && (_cls->saved_index < _cls->size);
    }
  protected:
    Class *_cls;
};
 
int main() {
  Class c;
  Check<ct_none> ck1(&c);
  Check<ct_no_nulss> c2(&c);
  Check<ct_index_bounds | ct_memory_leaks> c3(&c);
 
  c1.do_check();
  c2.do_check();
  c3.do_check();
 
  return 0;
}

Ainsi codé, Check et Class sont complètement indépendants, et Check peut se plugger sur n'importe classe, et Class ne contient plus aucune spécificité par rapport à Check.

Il n'y a plus d'héritages, et l'utilisation du framework est trés naturel.

Qu'est ce que vous en pensez ?