Discussion :

[Daikyo]

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.

[Joel F]

1/ distance appartient a Vec3 :

Code :

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

1
2
3
4
5
6
 
template <typename T>
double Vec3<T>::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));
}

2/ distance devrait etre une fonction libre et pas un truc static

3/ Pour renvoeyr un tableau, renvoti un boost::array<T,3> qui a une semantique du premier ordre contrairement a T[3]

[regis.portalez]

en plus de joel F :

les méthodes x(), y(), et z() doivent être const

les pow(x, 2), il vaut mieux éviter, ça prend un peu trop de temps par rapport à une simple multiplication...

sur ton destructeur, il faut caster ton m_values en T* pour éviter un warning de destruction de type incomplet.

[Goten]

en plus de joel F :

les méthodes x(), y(), et z() doivent être const

les pow(x, 2), il vaut mieux éviter, ça prend un peu trop de temps par rapport à une simple multiplication...

sur ton destructeur, il faut caster ton m_values en T* pour éviter un warning de destruction de type incomplet.

?

C'est surtout qu'il faut pas delete du tout... c'est un tableau statique.

[regis.portalez]

Ah ben oui en effet...

[Daikyo]

Bonjour et merci de vos réponses.

Si je rends la méthode distance libre (ce qui serait le plus logique, je le concède), j'ai d'autres erreurs de type :
no type named 'iterator_category' in 'class Vec3<double>'
no type named 'value_type' in 'class Vec3<double'
no type named 'difference_type' in 'class Vec3<double>'
etc...
dans stl_iterator_base_types.h ....

Ok pour les const et les pow par contre j'ai pas saisi le problème sur le destructeur.