Passage paramètre, return, ref, var etc
Bonjour à tous,
J'ai été emmené à me poser une question à laquelle je n'arrive pas à répondre...
J'ai une petite classe génerique dont je suis ammené à passer en paramètre régulièrement :
Voilà le template, avec quelques opérateur redéfinis, rien de méchant.
Elle permet de créer un vecteur borné de N élements de type T
Code:
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
| template <class T, int N>
class BornedVector
{
protected:
T _v[N];
public:
BornedVector ( ) { }
BornedVector(const BornedVector <T, N> & v)
{
for(int i = 0; i < N; ++i)
_v[i] = v._v[i];
}
virtual ~BornedVector ( ) { }
inline T & operator []( unsigned int index ) { return _v[index]; }
inline bool operator< ( const BornedVector <T, N> & v ) const
{
unsigned int index = 0;
bool equals = true;
while ( equals && index < N )
{
equals = (_v[index]._optiVertexIndex == v._v[index]._optiVertexIndex);
if ( equals ) ++index;
}
if ( equals )
return false;
else
return _v[index]._optiVertexIndex < v._v[index]._optiVertexIndex;
}
inline bool operator == ( const BornedVector <T, N> & v ) const
{
bool equals = true;
unsigned int i = 0;
while ( equals && i < N )
{
if ( _v[i] != v._v[i] )
equals = false;
else
++i;
}
return equals;
}
inline void operator = ( const BornedVector <T, N> & v )
{
for(int i = 0; i < N; ++i)
{
_v[i] = v._v[i];
}
}
}; |
Et une petite classe héritant du template, représentant un simple vecteur de 3 entier :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class Vec3i : public BornedVector <int, 3 >
{
public:
Vec3i ( int x = 0, int y = 0, int z = 0 ) : BornedVector <int, 3> ()
{
_v[0] = x;
_v[1] = y;
_v[2] = z;
}
inline int & x ( ) { return _v[0]; }
inline int & y ( ) { return _v[1]; }
inline int & z ( ) { return _v[2]; }
}; |
Voilà pour les présentations,
Ce qui me semble sombre est lors de la manipulation de mon Vec3i.
Prenons une fonction qui me construit et retourne un Vec3i :
J'ai changé le noms de fonction et les ait simplifié pour la lisibilité
Code:
1
2
3
4
| inline Vec3i f1 ( int x, int y, int z )
{
return Vec3i ( x, y , z );
} |
Que se passe t'il en mémoire ?
Le constructeur de Vec3i est bien appelé, ce qui est retourné n'est apriori pas une copie de mon Vec3i construit.
J'ai ensuite un appel de fonction
Code:
f2 ( f1 ( 1, 2, 3 ), f1 ( 2, 3, 4), f1 ( 3, 4, 5 ) );
Avec comme corps de fonction f2
Code:
1
2
3
4
| inline void fonction2 ( Vec3i A, Vec3i B, Vec3i C )
{
[...]
} |
Si je trace l'adresse de mes Vec3i , alors je vois que ceux qui arrivent dans f2 sont les même que ceux qui ont été construits par f1, donc pas de copie.
Cependant ... A B et C se retrouvent avec des valeurs aléatoire, comme si elle n'avaient jamais été initialisée, ce qui n'est pas le cas car il y a bien eu mon appel de constructeur ...
En bossant avec les réferences c'est bon, mais j'aimerai bien comprendre ce qu'il se passe dans ce cas là ! :p
Quelqu'un aurait il une idée ?
Merci de votre attention,
Harold
