Discussion :

[Aspic]

Bonjour à tous,

Je me demandais s'il était possible de savoir le nombre de paramètre réellement passé à mon constructeur de classe (sans passé par les va_arg, va_list,... du C) qui a des "template par défaut" :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template <typename T1, typename T2 = void*, typename T3 = void*>
class MA_CLASSE
{
MA_CLASSE(T1 _p1, T2 _p2 = (void*)0, T3 _p3 = (void*)0)
        : p1(_p1),  p2(_p2),  p3(_p3)
};
 
// exemples d'appel :
MA_CLASSE<int> c1; // un seul paramètre fourni
MA_CLASSE<int, float> c2; // 2 params
MA_CLASSE<int, flat, int> c3; // 3 paramètres

Je sais que ce n'est peut être pas très élégant de mettre des "void*" en C++ mais je n'ai pas trouvé d'autre solution pour pouvoir instancier ma classe template avec un ou plusieurs types.

Voilà, Merci à vous

[Trademark]

Salut,

Pour prendre les choses dans l'ordre :

le nombre de paramètre réellement passé à mon constructeur de classe

Utiliser l'overload de constructeur au lieu de paramètre par défaut ?

Si tu peux utiliser le C++11 tu peux considérer les variadic template qui pourraient convenir.

Sinon il y a un problème dans ton implémentation, quand tu utilises des arguments par défaut dans le constructeur tu leur affectes une valeur, or tu n'es pas sûre que cette valeur soit correcte en fonction du type. Par exemple je peux appeler ta classe comme ça :

Code :

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

Ma_classe<int, MonType> m(5);

Si MonType n'a pas un opérateur d'affectation prenant un (void*) alors tu auras une erreur de compilation.

Il existe plusieurs solutions pour régler ce genre de problème mais ça dépend vraiment du contexte et de la sémantique de ta classe. Si tu veux un avis qui soit personnalisé, dit nous ce que tu essayes de faire avec ta classe.

[Kalith]

Est-ce que tu cherches a avoir un tuple (ou avec boost si tu ne peux pas utiliser le c++11) ?

[koala01]

Salut,

Si tu peux utiliser C++11, tu aurais presque intérêt à utiliser les variadic template, de manière a avoir un nombre d'argument réellement variable.

Tu pourrait savoir exactement le nombre d'élément que tu as sous grace à sizeof :

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
#include <iostream>
template <typename ... Args>
struct MyStruct
{
    enum {size = sizeof...(Args)};
};
using NoArgs = MyStruct<>;
using OneArg = MyStruct<int>;
using TwoArgs = MyStruct<int, std::string>;
int main()
{
    std::cout<<"NoArgs has "<<NoArgs::size << " arguments"<<std::endl
             <<"OneArg has "<<OneArg ::size << " arguments"<<std::endl
             <<"TwoArgs has "<<TwoArgs ::size << " arguments"<<std::endl;
}

[Aspic]

Avec l'overload du contructeur, ca marche

Je viens de me renseigner sur le variadic template, ca a l'air super puissant ce truc (je ne connaissais pas du tout).

Par contre, comment on fait pour récupérer les types et les valeurs des paramètres vairables ? lol

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
template <typename ... Args>
struct MyStruct
{
    enum {size = sizeof...(Args)};
 
    MyStruct()
    {
        std::cout << "comment récupérer mes types ?" << std::endl;
    }
};
 
// et son appel :
MyStruct<int, float> toto(5, 10.5);

Le but en fait est de créer une classe avec des paramètres génériques variables. Donc si je fais par exemple : Param<int, float, double>, je voudrais créer une classe avec 3 membres int m_1, float m_2, double m_3
Et si j'appel comme cela : Param<int> alors je n'ai que int m_1

PS : je n'ai pas trouvé de très bon article sur ce sujet (en français ), celui la est assez incompréhensible :
http://blog.emmanueldeloget.com/inde...es-variadiques

PS 2 : Je n'utilise pas Boost.

Merci

[Kalith]

Au risque de répéter un peu ce qui a déjà été dit : pour t'aider plus au delà, il faudrait savoir ce que tu cherches à faire avec cette classe. L'exemple de Koala est joli, mais il ne te montre pas ce qu'il y a de plus dur à faire, c'est à dire justement créer des variables membres selon les types templates.

Tu as des gens qui ont déjà pris la peine de le faire, par exemple dans le standard c++11 :

Code :

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

1
2
3
4
5
6
7
8
9
#include <tuple>
#include <iostream>
 
int main() {
    std::tuple<int, float> toto(5, 10.5);
    std::cout << "premiere valeur : " << std::get<0>(toto) << std::endl;
    std::cout << "seconde valeur  : " << std::get<1>(toto) << std::endl;
    return 0;
}

Plusieurs questions donc :

• est-ce que toutes tes instances de MaClasse doivent avoir 3 variables membres, et tu veux juste pouvoir n'en initialiser que quelques unes ?
• dans le cas contraire, est-ce que tu auras toujours 3 types au maximum, ou est-ce que ça peut changer ?
• et est-ce que tu vas toujours utiliser MaClasse avec de types fixes (ex : int, float, int), ou est-ce que ça peut changer ?
• à quoi ça sert ?