Voila la definition d'une classe de vecteur 3D, c'est assez utile pour les programmes OpenGL par exemple.
La classe ne contient pas toutes les opérations mais les plus importantes :
==, =, +, -, *, /, ., ^, norm, normalize.
Source / Exemple :
/**************************************************************************************
*
*
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
class Vector3D
{
public:
/*---------------------------------- Constructor --------------------------------*/
Vector3D () {}
Vector3D (float X, float Y, float Z)
{
x = X; y = Y; z = Z;
}
/*---------------------------------- Operators ----------------------------------*/
// Return himself
operator Vector3D () const
{
return Vector3D(x, y, z);
}
// Add vector
Vector3D operator + (Vector3D Vector)
{
return Vector3D (Vector.x + x, Vector.y + y, Vector.z + z);
}
// Subtract vectors
Vector3D operator - (Vector3D Vector)
{
return Vector3D (x - Vector.x, y - Vector.y, z - Vector.z);
}
// "produit vectoriel"
Vector3D operator ^(Vector3D Vector)
{
Vector3D vNormal;
vNormal.x = ((y * Vector.z) - (z * Vector.y));
vNormal.y = ((z * Vector.x) - (x * Vector.z));
vNormal.z = ((x * Vector.y) - (y * Vector.x));
return vNormal;
}
// Divide by a scalar
Vector3D operator * (float num)
{
// Return the scaled vector
return Vector3D(x * num, y * num, z * num);
}
// "produit scalaire"
float operator * (Vector3D Vector)
{
return (x * Vector.x + y * Vector.y + z * Vector.z);
}
// Divide by a scalar
Vector3D operator / (float num)
{
// Return the scale vector
return Vector3D(x / num, y / num, z / num);
}
// = operator
void operator = (Vector3D Vector)
{
x = Vector.x;
y = Vector.y;
z = Vector.z;
}
// == operator
bool operator == (Vector3D Vector)
{
return (x == Vector.x && y == Vector.y && z == Vector.z);
}
// != operator
bool operator != (Vector3D Vector)
{
return (x != Vector.x || y != Vector.y || z != Vector.z);
}
/*---------------------------------- Functions ----------------------------------*/
// Work out the norm of our vector
float Norm()
{
// Norme = sqrt(x^2 + y^2 + z^2)
return (float)sqrt( Vector3D(x,y,z) * Vector3D(x,y,z) );
}
// Work out the vector normalized : Vector.norm() == 1
Vector3D Normalize()
{
return (Vector3D(x,y,z) / Norm());
}
float x, y, z;
};
Conclusion :
exemple :
Vector3D Vector1(0.0,4.0,0.0);
Vector3D Vector2(9.0,6.0,0.0);
Vector3D Vector3(0.0,0.0,0.0);
float result;
char buffer[255];
Vector3 = Vector1 ^ Vector2;
result = Vector1 * Vector2;
sprintf(buffer, "(0.0,4.0,0.0)) ^ (9.0,6.0,0.0) = (%f,%f,%f)", Vector3.x, Vector3.y, Vector3.z);
MessageBox(NULL,buffer,"RESULT",MB_OK);
sprintf(buffer, "(0.0,4.0,0.0) * (9.0,6.0,0.0) = %f", result);
MessageBox(NULL,buffer,"RESULT",MB_OK);
sprintf(buffer, "Norm of Vector3 = %f", Vector3.Norm());
MessageBox(NULL,buffer,"RESULT",MB_OK);
7 nov. 2005 à 02:18
Pour un programme que j'ai fait récemment, j'ai eu besoin d'une classe vecteur. Mon code marchait plutôt bien à un petit détail près. J'ai eu un petit problème avec la surcharge des opérateurs +, -, etc. et << que j'ai redéfini pour afficher les vecteurs en texte sous la forme "(x, y, z)".
Dans un premier temps, j'ai défini les opérateurs arithmétiques de la manière suivante :
vecteur operator+(const vecteur &v) {
vecteur tmp;
tmp.x = x + v.x;
tmp.y = y + v.y;
tmp.z = z + v.z;
return tmp;
}
Cela marchait très bien pour les calculs mais pas pour l'affichage. C'est-à-dire que pour afficher la somme de deux vecteurs, je devais faire :
v = v1 + v2;
cout<<v;
Dans le cas où je mettais juste "cout<<(v1 + v2);", j'avais un message d'erreur.
Pour résoudre ce problème, j'ai redéfini les opérateurs comme cela :
vecteur &operator+(const vecteur &v) {
vecteur &tmp;
tmp->x = x + v.x;
tmp->y = y + v.y;
tmp->z = z + v.z;
return *tmp;
}
Cette solution semble fonctionner aussi bien pour le calcul que pour l' affichage. Cependant, je me demande si elle est bien correcte. Car si j'ai bien compris, on transmet juste l'adresse de la variable tmp et celle-ci est détruite juste après l'opération. Si c'est le cas, ça marcherait donc juste par hasard parce qu'aucun autre processus ne serait venu altérer la mémoire à cet endroit-là.
Est-ce que quelqu'un pourrait m'expliquer ce qui ne marche pas avec la première méthode et pourquoi la deuxième méthode qui me semble incorrecte marche?
D'avance merci.
5 mars 2005 à 11:19
4 mars 2005 à 22:57
4 mars 2005 à 22:57
#ifdef DEBUG
if(nul == 0)
cout << "Division de vecteur par 0!" << endl;
#endif
L'effet, ce sera d'avertir le programmeur pdt le débuggage, et puis ben pr le reste il n'aura qu'à faire le test lui même, ça me paraît plus logique.
4 mars 2005 à 20:55
float operator * (Vector3D Vector)
{
return (x * Vector.x + y * Vector.y + z * Vector.z);
}
met ca:
float operator * (const Vector3D & Vector)
{
return (x * Vector.x + y * Vector.y + z * Vector.z);
}
C'est beaucoup plus rapide, car tous ceux qui programment sur openGL ont besoin de performance.
De plus, j'ai fais ma propre classe vecteur 3D, en template, ce qui me permet de modifier le type de données de mes vecteurs, genre int, float, double, etc ..., ou autre. Ca peut présenter un intérêt.
De plus, si je vais vecteur / 0 ? il se passe quoi ? il faut donc gérer tous les cas possible pour rendre une classe de vecteur utilisable par tout le monde. Et dernière chose, je pense qu'il vaut mieux séparer en .h et .cpp ou .inl si tu déclares les fonctions en inline.
Dernières chose, si V est un vecteur,
X 4*V, ta classe le gère ? ou alors il faut mettre X V*4
Aller ++ :)
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.