Discussion :

[_SamSoft_]

Bonjour, je suis en train de développer une petite application "test" pour ma futur lib de maths et je rencontre un problème bien étrange. J'ai vérifié dans mon bouquin, mais du point de vue code, je ne vois aucune erreur. Je suis parti sur le net idem.

Voilà le code :

main.cpp (basique) :

Code :

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

1
2
3
4
5
6
7
8
 
#include "Point2d.hpp"
 
int main(void)
{
    izk::Point2d<int> pt(2, 3);
    return 0;
}

Point2d.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
 
#ifndef POINT2D_HPP
#define POINT2D_HPP
 
namespace izk
{
    template <typename T> class Point2d
    {
        public:
            Point2d();
            Point2d(T x, T y);
            T getX() const;
            T getY() const;
            void setX(T x);
            void setY(T y);
            void setPosition(T x, T y);
        private:
            T m_x;
            T m_y;
    };
}
 
#endif // POINT2D_H

Point2d.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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
#include "Point2d.hpp"
 
namespace izk
{
    template <typename T> Point2d<T>::Point2d()
    {
    }
 
    template <typename T> Point2d<T>::Point2d(T x, T y)
    {
        m_x = x;
        m_y = y;
    }
 
    template <typename T> T Point2d<T>::getX() const
    {
        return m_x;
    }
 
    template <typename T> T Point2d<T>::getY() const
    {
        return m_y;
    }
 
    template <typename T> void Point2d<T>::setX(T x)
    {
        m_x = x;
    }
 
    template <typename T> void Point2d<T>::setY(T y)
    {
        m_y = y;
    }
 
    template <typename T> void Point2d<T>::setPosition(T x, T y)
    {
        m_x = x;
        m_y = y;
    }
}

J'utilise la version finale de code::blocks (enfin celle sortie il n'y a pas longtemps et qui est une version stable). Je suis sous Linux (rien à voir avec le problème mais bon).

Voilà l'erreur retournée :

main.cpp.text+0x28)||undefined reference to `izk::oint2d<int>::point2d(int, int)'|

Dois-je définir le comportement du constructeur si c'est un int alors que j'ai dis que ca pouvait l'être (via le système de templates),
si oui alors comme dirai Jean Pierre Coff : "C'est de la merde !" :mouarf:

Merci d'avance :)

Ps:
Je suis parti voir des sources d'une lib (la SFML) et quand je regarde je vois :
Vector2.hpp et Vector2.Inl (qui plus est, je l'ouvre et aucune référence à Vector2.hpp n'est tapé donc y a pas son inclusion) et pas de Vector2.cpp
A quoi cela correspond ?

[Klaim]

La déclaration ET la définition d'une classe template doivent être dans le header.

Soit tu copies le contenu de Point2d.cpp dans Point2d.h (après la déclaration), soit tu ajoutes à la fin de Point2d.h (avant le #endif ) :

Code :

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

1
2
 
#include "Point2d.cpp"

La copie est plus propre a mon avis, sauf si tu préfère séparer auquel cas j'aurais renommer Point2d.cpp en Point2d.inl ou autre que cpp.

[Scorpi0]

Je rajouterai (sans en être sur) que c'est le pré-compilateur qui s'occupe créer autant de classe de nécessaire définit par ton template.

Le pré compilateur ne pouvant pas générer lesdites fonction template, elle n'existe donc pas, d'où l'erreur que tu obtient.

[zabibof]

Vector2.hpp et Vector2.Inl (qui plus est, je l'ouvre et aucune référence à Vector2.hpp n'est tapé donc y a pas son inclusion)

Mais quelque part à la fin de Vector2.hpp, tu devrais voir un

Code C++ :

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

1
2
 
#include "Vector2.inl"

[Montag]

Je rajouterai (sans en être sur) que c'est le pré-compilateur qui s'occupe créer autant de classe de nécessaire définit par ton template.

Le pré compilateur ne pouvant pas générer lesdites fonction template, elle n'existe donc pas, d'où l'erreur que tu obtient.

Bon déjà je ne sais pas ce qu'est un pré-compilateur en C++. Maintenant, si par pré-compilateur tu entends préprocesseur je tiens à te dire que celui-ci n'a rien à voir avec les templates.

[_SamSoft_]

Ca fonctionne très bien avec la solution de Klaim
Effectivement zabibof, cette ligne existe bien, je ne l'avais pas vu (ouf, je comprends mieux)

La déclaration ET la définition d'une classe template doivent être dans le header.

En est il de même pour les patrons de fonctions (en dehors d'un patron de classe) ?

Merci d'avance

[Klaim]

Tout ce qui est templaté, oui.

[_SamSoft_]

Merci à vous,

résolu

[Scorpi0]

Bon déjà je ne sais pas ce qu'est un pré-compilateur en C++. Maintenant, si par pré-compilateur tu entends préprocesseur je tiens à te dire que celui-ci n'a rien à voir avec les templates.

Effectivement, j'avais tout faux ^^

Extrait (http://www.cplusplus.com/doc/tutorial/templates.html) :

Templates and multiple-file projects

From the point of view of the compiler, templates are not normal functions or classes. They are compiled on demand, meaning that the code of a template function is not compiled until an instantiation with specific template arguments is required. At that moment, when an instantiation is required, the compiler generates a function specifically for those arguments from the template.

When projects grow it is usual to split the code of a program in different source code files. In these cases, the interface and implementation are generally separated. Taking a library of functions as example, the interface generally consists of declarations of the prototypes of all the functions that can be called. These are generally declared in a "header file" with a .h extension, and the implementation (the definition of these functions) is in an independent file with c++ code.

Because templates are compiled when required, this forces a restriction for multi-file projects: the implementation (definition) of a template class or function must be in the same file as its declaration. That means that we cannot separate the interface in a separate header file, and that we must include both interface and implementation in any file that uses the templates.

Since no code is generated until a template is instantiated when required, compilers are prepared to allow the inclusion more than once of the same template file with both declarations and definitions in a project without generating linkage errors.

Traduction :

Templates et projets à fichiers multiples

Du point de vue du compilateur, les templates ne sont pas des fonctions ou des classes normales. Ils sont compilés à la demande, ce qui veut dire que le code d'un template n'est pas compilé jusqu'à rencontrer une instanciation qui le requiert. A ce moment, quand une instanciation est faite, le compilateur génère la fonction spécialement pour les types d'arguments requit.

Quand un projet grossit, il est habituel de séparer le code en différents fichiers sources. Dans ce cas, l'interface et l'implémentation sont séparés. Par exemple, pour une librairie, l'en-tête contient seulement les déclarations des fonctions qui peuvent être utilisées (fichiers .h), et l'implémentation est dans des fichiers sources séparés.

Comme les templates sont compilés si nécessaire, une restriction est imposée pour les projets à multiples source : l'implémentation des templates doit être dans le même fichier que leur déclaration. Nous ne pouvons séparer l'interface dans un fichier header séparé, et nous devons inclure en même temps l'interface et l'implémentation dans tout les fichiers utilisant le template.

Puisqu'aucun code n'est généré jusqu'à ce qu'un template soit instancié, le compilateur autorise plusieurs inclusions du même template (soit l'interface et l'implémentation) sans générer d'erreurs de linkage.


Je me coucherai moins bête ce soir