Discussion :

[m0ul3sh0t]

Bonjour tout le monde,
Je me permets de venir vers vous pour une question ridicule mais où je suis incapable de trouver la solution...

J'ai actuellement une classe définie comme ceci
socketshandler.hpp

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
 
#ifndef __SOCKETSHANDLER_HPP__
# define __SOCKETSHANDLER_HPP__
 
#  include <iostream>
 
class   SocketsHandler
{
/* Variables */
private:
public:
    enum        TYPE { RabbitMQ };
 
/* Methods */
private:
 
public:
    SocketsHandler();
    ~SocketsHandler();
 
    template <typename ...Args>
    void        addHandler(SocketsHandler::TYPE type, Args &&...args);
};
 
#endif // !__SOCKETSHANDLER_HPP__

socketshandler.cpp

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
 
#include "socketshandler.hpp"
 
//-----------------------------------------------------
SocketsHandler::SocketsHandler()
//-----------------------------------------------------
{
}
 
//-----------------------------------------------------
SocketsHandler::~SocketsHandler()
//-----------------------------------------------------
{
}
 
 
//-----------------------------------------------------
template <typename ...Args>
void        SocketsHandler::addHandler(SocketsHandler::TYPE type, Args &&...args)
//-----------------------------------------------------
{
}

et le main

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#include "socketshandler.hpp"
 
int main()
{
 
    SocketsHandler  toto;
 
    toto.addHandler(SocketsHandler::TYPE::RabbitMQ, "Toto", "tata");
 
}

Le problème est que quand je compile j'obtiens le message suivant

test.cpp.text+0x2c): undefined reference to `void SocketsHandler::addHandler<char const (&) [5], char const (&) [5]>(SocketsHandler::TYPE, char const (&) [5], char const (&) [5])'

Ce que je ne comprends pas c'est que si je définis ma fonction "addHandler" dans mon .hpp, je n'ai pas l'erreur...
Je n'arrive pas à voir ce que je fais de mal

Est-ce que quelqu'un peut m'aiguiller?
J'ai beau chercher sur les templates ou sur les variadics... je ne trouve rien qui pourrait m'aider

[ternel]

en très bref:
la règle de base est "template XOR cpp".
PS: comme tout conseil, on peut trouver des exceptions.

en plus long:
Une template n'est pas du code, mais un moyen d'indiquer au compilateur comment générer du code.
Lorsque tu inclues un en-tête, il est copié dans le code qui l'inclue. Du coup, seul la déclaration de la template est visible.
Au moment de générer la fonction, le compilateur à besoin de tout le code.
Il n'y a que deux solutions possibles:

1. placer le code de la fonction dans l'en-tête la déclarant (directement, en bas de fichier, ou dans un fichier systématiquement inclus après la déclaration)
2. forcer l'instanciation de certaines situations, les autres étant impossibles à utiliser.

Dans le cas présent, c'est une template variadique (qui utilise un "parameter pack", le ...), donc c'est très certainement la première solution qu'il faut choisir.

Nous avons une entrée dans notre faq à ce sujet: Pourquoi mes templates ne sont-ils pas reconnus à l'édition des liens?


Conclusion:
Fais voir ton code quand tu définis la fonction dans l'en-tête?

PS: par contre, tu cours à la catastrophe avec cette technique, ta template va être un énorme switch pas beau du tout.
Je t'invite à placer le type de socket dans les parametres templates

[m0ul3sh0t]

Salut ternel,
Tout d'abord merci pour ton retour et ton explication.

en très bref:
Conclusion:
Fais voir ton code quand tu définis la fonction dans l'en-tête?

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
 
class   SocketsHandler
{
/* Variables */
private:
public:
    enum                        TYPE { Type1 };
 
/* Methods */
private:
 
public:
    SocketsHandler();
    ~SocketsHandler();
 
    template <typename ...Args>
    void        addHandler(SocketsHandler::TYPE type, Args &&...args)   {
        switch(type)    {
            case SocketsHandler::TYPE::Type1:
                 ...
                break;
 
            default:
                std::cout << "Not handled" << std::endl;
        };
    }
};

PS: par contre, tu cours à la catastrophe avec cette technique, ta template va être un énorme switch pas beau du tout.
Je t'invite à placer le type de socket dans les parametres templates

Je ne suis pas sûr de comprendre. Tu veux dire que je devrais définir ma fonction addHandler de la forme ?

Code :

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

1
2
3
4
5
 
    template <typename T, typename ...Args>
    void        addHandler(Args &&...args)   {
           ...
    }

ou d'utiliser le design pattern Fabrique?

[ternel]

En gros, c'est dommage de créer une template pour faire un switch sur un argument.
Ca veut dire que tu as toute la puissance des templates pour controler ce que tu appelles, et finalement, tu fais juste un "switch default throw", dans chaque fonction généré par la template.

On en parle quand ton problème d'édition des liens sera résolu.
Avec le code dans l'en-tête, ca devrait fonctionner.

Si ce n'est pas le cas:

1. As-tu activés tous les warnings (pour g++, c'est -Wall, voire -Wall -Wextra).
2. As-tu corrigé ceux présents?

[m0ul3sh0t]

Yes j'ai corrigé en basculant mon code dans le .hpp mais du coup, au vue de tes explications j'ai modifié complètement mon code...

En y réfléchissant à nouveau, je complexifiais énormément le code pour un gain qui ne me servira pas. Le polymorphisme suffira dans mon cas présent

Encore merci pour le temps consacré.