Bonjour, je développe une classe template qui contient, entre autre, une méthode statique, le tout implémenté de la façon suivante :

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
template <typename T>
class Vec3
{
private:
    T m_values[3];
 
public:
    Vec3(const T& _value1 = T(), const T& _value2 = T(), const T& _value3 = T());
    Vec3(const Vec3<T>& _vector);
    ~Vec3();
 
    T x() { return m_values[0]; }
    T y() { return m_values[1]; }
    T z() { return m_values[2]; }
 
    void setX(T _value) { m_values[0] = _value; }
    void setY(T _value) { m_values[1] = _value; }
    void setZ(T _value) { m_values[2] = _value; }
    void set(Vec3<T> _vector) { setX(_vector.x()); setY(_vector.y()); setZ(_vector.z()); }
 
    T* toArray() { return m_values; }
 
    static double distance(const Vec3<T>& _vec1, const Vec3<T>& _vec2);
    static double dotProduct(const Vec3<T>& _vec1, const Vec3<T>& _vec2);
    static Vec3<T> crossProduct(const Vec3<T>& _vec1, const Vec3<T>& _vec2);
};
 
// CONSTRUCTEURS
template <typename T>
Vec3<T>::Vec3(const T& _value1, const T& _value2, const T& _value3)
{
    setX(_value1);
    setY(_value2);
    setZ(_value3);
}
 
template <typename T>
Vec3<T>::Vec3(const Vec3<T>& _vector)
{
    set(_vector);
}
 
// DESTRUCTEUR
template <typename T>
Vec3<T>::~Vec3()
{
    delete [] m_values;
}
 
// DISTANCE
template <typename T>
double distance(const Vec3<T>& _vec1, const Vec3<T>& _vec2)
{
    return (sqrt(pow(_vec2.x() - _vec1.x(), 2)) + pow(_vec2.y() - _vec1.y(), 2) + pow(_vec2.z() - _vec1.z(), 2));
}
 
// PRODUIT SCALAIRE
template <typename T>
double dotProduct(const Vec3<T>& _vec1, const Vec3<T>& _vec2)
{
    return (_vec1.x * _vec2.x + _vec1.y * _vec2.y + _vec1.z * _vec2.z);
}
 
// PRODUIT VECTORIEL
template <typename T>
Vec3<T> crossProduct(const Vec3<T>& _vec1, const Vec3<T>& _vec2)
{
    Vec3<T> vector;
    vector.setX((_vec1.y * _vec2.z) - (_vec1.z * _vec2.y));
    vector.setY((_vec1.z * _vec2.x) - (_vec1.x * _vec2.z));
    vector.setZ((_vec1.x * _vec2.y) - (_vec1.y * _vec2.x));
    return vector;
}
 
 
typedef Vec3<int> Vec3i;
typedef Vec3<float> Vec3f;
typedef Vec3<double> Vec3d;
typedef Vec3<unsigned char> Vec3uc;
Et dans mon main, je fais :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
Vec3d vec1 = Vec3d(3.0, 3.0, 3.0);
Vec3d vec2 = Vec3d(1.0, 1.0, 1.0);
 
cout<<Vec3d::distance(vec1, vec2)<<endl;
Et ça me renvoie cette erreur :
"undefined reference to 'Vec3<double>::distance(Vec3<double> const&, Vec3<double> const&)'"

Pourtant l'implémentation est bien là donc je ne comprends pas le souci.

Ah, et j'ai une petite question sans rapport mais si j'avais mis T x, T y, T z à la place d'un tableau de 3 T, comment est-ce que j'aurais pu faire pour renvoyer un tableau à partir de la méthode toArray() ? Si je crée un tableau à partir des 3 variables dans la méthode et que je le retourne, ça fonctionne bizarrement selon le compilateur vu que c'est un un tableau local à la méthode.