Discussion :

[boubouboy]

Bonjour,

Je me pose la question suivante:

J'ai une classe GenericTemplate qui utilise plusieurs types de données différentes.
Dans cette classe j'aimerai créer des classes Templates PartialTemplate1 et PartialTemplate2 qui ne traitent que certains type de données.

Sur l'appel de la méthode onfind de la class GenericTemplate, j'aimerai qu'en fonction du type de la donnée cela m'oriente vers l'appel de la class PartialTemplate1 ou PartialTemplate2.
Jusque la, OK. J'aurai pu le gérer mieux qu'avec un enum, mais c'est juste pour monter l'idée, ma question étant la possibilité ou l'impossibilité a utiliser des classes ne possédant pas les méthodes sur tous les types, et ne pas être obligé de déclarer un template et de ne specialiser que les cas qui m'intéresse dans chaque classe

Est il possible de n'avoir que les types qui m'intéresse pour leur traitement dans B et dans C sans être obligé de déclarer les types utilisé par l'autre classe ( et donc avoir des méthodes vides) ?

j'aimerai quelque chose du genre:

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
80
81
82
83
84
85
 
#include <iostream>
#include <string>
#include <cstdint>
#include <vector>
#include <cstdarg>
#include <algorithm>
 
class A
{
   public:
      A() = default;
      ~A() = default;
};
 
class B
{
   public:
      B() = default;
      ~B() = default;
};
 
class PartialTemplate1
{
   public:
      static void onFind(A value){};      
 
 
};
 
class PartialTemplate2
{
   public:
      static void onFind(B value){};
 
};
 
//J'aimerai eviter de faire : 
/*
class PartialTemplate2
{
   public:
     template<typename T> static void onFind(T value){};
     template<> static void onFind(B value){};
 
};
*/
 
 
 
class GenericTemplate
{
   public:
 
   enum V_E
   {
      E_1,
      E_2
   };
 
      template<typename T> static void onFind(T value, V_E e)
      {
         switch(e)
         {
            case E_1:
               PartialTemplate1::onFind(value);
               break;
            case E_2:
               PartialTemplate2::onFind(value);
               break;
            default:
               break;
         }
      }
 
 
};
 
 
int main()
{
A a;
GenericTemplate::onFind(a, GenericTemplate::E_1);
 
}

je vous remercie!

[deedolith]

Salut,

Tu as regardé du coté des spécialisations ?
https://en.cppreference.com/w/cpp/la...specialization

[dalfab]

Bonjour,

Je ne comprends pas pourquoi tu aurais besoin de créer des fonctions membres template. De plus dans ton exemple, les fonctions sont static et dans ce cas avec des fonctions libres, ça marche directement

Code :

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

1
2
3
4
5
6
7
8
9
void  onFind( A value ) {  PartialTemplate1::onFind( value ); }
void  onFind( B value ) {  PartialTemplate2::onFind( value ); }
 
class GenericTemplate {
   public:
      template<typename T> static void  onFind( T value ) {
         onFind( value );
      }
};

Il manque peut-être un exemple plus complet la situation initiale pour mieux comprendre ton soucis.

[Bktero]

J'ai l'impression que tu as soit :

1- trop réduit ton code et qu'on ne comprend plus vraiment ce que tu veux faire
2- tu ne nous décris pas ton problème d'origine et tu nous donnes de faire fonctionner un "mauvais" code (dans le sens où il y aurait une meilleure solution à ton problème d'origine)

Si tu appelles Classe::methode(), il n'y a aucun raison que ton compilateur n'appelle AutreClasse::methode().

La seule situation où tu peux avoir quelque chose dans ce style, c'est dans le cas du polymorphisme de sous-typage : tu as une instance de AutreClasse que tu manipules via un pointeur ou une référence de Classe. Mais dans un tel cas, on cherche simplement la "vraie" méthode de la classe réelle de l'objet. En aucun cas, ce "dispatche" se fait sur le type du paramètre dans le cas du polymorphisme.

Si tu veux que le compilateur choisisse une fonction en se basant sur le type du paramètre, il faut faire utiliser la surcharge, comme suggéré par dalfab. Tu n'aurais alors plus besoin de classes (c'est pour ça que j'ai l'impression 1 / 2 évoquée au début de mon message) :

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
#include <iostream>
 
struct A {};
struct B {};
struct C {};
 
void onFind(const A&) { std::cout << __PRETTY_FUNCTION__ << '\n';}
void onFind(const B&) { std::cout << __PRETTY_FUNCTION__ << '\n';}
 
template<typename T> 
void onFind(const T&) { std::cout << __PRETTY_FUNCTION__ << '\n';}
 
int main() {
    A a;
    B b;
    C c;
 
    onFind(a);
    onFind(b);
    onFind(c);
}

Sortie console :

void onFind(const A&)
void onFind(const B&)
void onFind(const T&) [with T = C]

Tu pourrais peut-être nous en dire un peu plus sur ton problème d'origine, comme ça on pourrait mieux comprendre ce que tu souhaites faire et te donner la solution la plus adaptée

EDIT : le titre de la discussion parle de "sous-classe" ; pourtant, il n'y en a pas dans ton code. Normal ?

[foetus]

tu peux faire tes propres conversions de tes classes.
Mais pour cela, il faut que tu puisses transformer "tes données" d'1 type vers 1 autre.

plus d'explication en anglais sur cppreference.com : user-defined conversion function.
Elles peuvent être virtuelles, héritées, template, mais pas static et apparemment elles passent toujours "en deuxième position".
Et à l'origine, c'était pour forcer les conversions vers les types de base : int, double, char, …

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
#include <iostream>
#include <cstdlib>
 
// Forward Declaration
struct A;
 
 
struct B {
    int varb;
 
    B(int input_b=0): varb(input_b) {}
};
 
 
struct A {
    int vara;
 
    A(int input_a=0): vara(input_a) {}
 
    operator B() const { return B(vara); }
};
 
 
void onFind(const B& b) {
    std::cout << "onFind: " << b.varb << std::endl;
}
 
 
int main()
{
    A a(15);
    onFind(a);
 
 
    return EXIT_SUCCESS;
}