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
|
// la sémantique mathématique est a revoir: il est impossible,
// mathématiquement, de multiplier une matrice 4x4 par un
// vecteur 1x3. Je te conseille de renommer cette fonction
// selon l'opération qui est réellement effecutée (projection ?
// rotation ? transform ?...).
// Ton code effectue une multiplication entre la matrice 3x3
// supérieure gauche et un vecteur 1x3. La solution pourrait
// consister a faire une fonction qui extrait la matrice 3x3 en
// question dans une classe Matrix3x3 et de coder l'opérateur
// Vector3D operator*(const Matrix3x3&, const Vector3D&).
template <class T>
Vector3D<T> operator*(const Matrix4x4<T> &m, const Vector3D<T> &v)
{
// on crée la valeur de retour et on l'initialise directement
Vector3D<T> ret(0,0,0);
// le bloc alloué ici est perdu a cause de la ligne suivante
// T *Tb = new T[16];
// écrase la valeur de Tb courante
// Tb = v.getArray();
// les blocs alloués ici sont perdus à cause de l'affectation suivante
// T **mat = new T*[4];
// for (int i = 0; i < 4; i++)
// mat[i] = new T[4];
// écrase la valeur de mat courante
// mat = m.getArray4x4();
// ---------
// on remplace le tout par 2 appels de fonction, qui renvoie les
// tableaux necessaires au calcul. Puisque ceux ci ne sont pas
// modifiés, pas besoin de copie:
// on peut d'ailleurs se passer de Tb, donc je le met directement
// en commentaire
// T* Tb = v.getArray();
T** mat = m.getArray4x4();
// ça, on va pas en avoir besoin
// T S = 0;
// on ré-écrit la boucle; on va travailler sur ret directement.
T* Tret = ret.getArray();
// la boucle elle même.
// Comme je l'ai dit plus haut, ton code semble faire une multiplication
// de la matrice 3x3 supérieure gauche: S est discardé si i == 3 donc
// l'exécution de "S += mat[i][j]*v[j];" ne sert à rien si i == 3. Tu peux
// changer la condition d'arrêt sur i, ce qui t'évite de faire un test à
// l'intérieur de la boucle.
for (int i=0; i<3; ++i)
{
for (int j=0; j<3; ++j)
{
Tret[i] += mat[i][j] * v[j];
}
}
// et bien sur, tout ça vire... (d'autant plus que ça n'est pas correct:
// Tb pointe sur les données de v, donc elles sont modifiées au fur et
// à mesure du calcul...)
// for (int i = 0; i < 4; i++)
// {
// for (int j = 0; j < 3; j++)
// S += mat[i][j]*v[j];
// if (i < 3)
// Tb[i] = S;
// S = 0;
// }
// Plus besoin de ça puisque ret est correctement initialisé...
// ret.x = Tb[0];
// ret.y = Tb[1];
// ret.z = Tb[2];
// soyons fous: retournons une copie de ret!
// return Vector3D<T>(ret.x, ret.y, ret.z);
return ret;
// code non atteint - et tant mieux...
// for(int i = 0; i < 4; i++)
// delete [] mat[i];
// delete [] mat;
} |
Paramètre de fonction non reconnu dans la fonction
Envoyé par g++
Répondre avec citation
Tous est résolu enfin presque...
Partager