Discussion :

[frankgoestohollywood]

Bonjour,

J'ai une classe template Bmp qui contient une image bitmap. Cette classe peut être instanciée
avec un type ou un type RBG24_t Gray_t.

Le RGB24_t contient:
un champ de 8 bits pour le rouge
un champ de 8 bits pour le vert
un champ de 8 bits pour le bleu

Le Gray_t contient:
-un champ de 8 bits pour l'intensité de gris

Je tiens à ajouter une méthode pour calculer l'intensité moyenne. mais elle doit travailler différemment
selon le paramètre:

Pour RGB24_t:

averageRed = somme de la composante rouge / nb pixels
averageGreen = somme des composante verte / nb pixels
averageBlue = somme des composante bleue / nb pixels


Pour Gray_t:

moyenne = somme de l'intensité de gris / nb pixels


La déclaration devrait ressembler a:

ComputeAverageIntensity int (composant char); / / le composant est «r», «g», «b», «a», où a est pour le gris.

Mais comment la méthode peut-elle connaître le type d'instanciation? Elle doit verifier que le «a» est utilisé uniquement quand Gray_t est utilisé, aucun r, g, b lorsque Gray_t est utilisé, seul r, g, b lorsque RBG24_t.

Vous pouvez proposer une autre mise en œuvre de la méthode, mais je ne peux pas changer le fait que la classe est un template.

je vous remercie!

[Emmanuel Deloget]

La réponse tiens en deux mots :

traits
policy

Les traits sont des classes qui donnent des informations sur le type passé en paramètre, tandis que les policy sont des stratégies appliquées au type en question. On peut combiner les deux, pour un résultat intéressant.

Il est important de noter que les traits en particuliers sont nés de la possibilité de spécialiser (partiellement ou complètement) un template déjà défini pour en modifier la définition et/ou le comportement.

Généralement, les traits s'utilisent ainsi :

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
 
// traits de base : ne défini rien ; il est illégal de l'utiliser
template <class T>
struct color_traits
{ };
 
// spécialisé pour rgb_t
template <>
struct color_traits<rgb_t>
{
    typedef int average_type;
    average_type compute_average(const rgb_t& c)
    { return (int(c.r) + int(c.g) + int(c.b)) / 3; }
};
 
// spécialisé pour gray_t
template <>
struct color_traits<gray_t>
{
    typedef int average_type;
    average_type compute_average(const gray_t& c)
    { return int(c); }
};
 
template <class T, class Traits = color_traits<T> >
class color
{
public:
    typedef color<T,Traits> self_type;
    typedef Traits traits_type;
    typedef T value_type;
 
private:
    value_type m_color;
 
public:
   static typename traits_type::average_type 
     compute_average(const self_type& c)
   {
      return traits_type::compute_average(c.m_color);
   }
   typename traits_type::average_type 
     compute_average()
   {
      return traits_type::compute_average(m_color);
   }
};

Lorsque tu instancies color<rgb_t>, il utilise par défaut le color_traits<rgb_t>, mais tu peux en spécifier un autre (au cas où tu aimes changer les comportements ). Lorsque tu instancie color<gray_t>, c'est color_traits<gray_t> qui est automatiquement utilisé.