Class vecteur 3d

Soyez le premier à donner votre avis sur cette source.

Snippet vu 12 260 fois - Téléchargée 37 fois

Contenu du snippet

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 :


/**************************************************************************************
*

  • Name : Vector3D.h
*
                                                                                                                                                                            • /
#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);

A voir également

Ajouter un commentaire

Commentaires

Messages postés
2
Date d'inscription
lundi 7 novembre 2005
Statut
Membre
Dernière intervention
12 mai 2006

Bonjour,

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.
Messages postés
2023
Date d'inscription
mardi 24 septembre 2002
Statut
Membre
Dernière intervention
28 juillet 2008
5
En effet, moi c'était envoyé au gestionnaire d'exception, mais dans ce cas, tu as raison, on ne peut rien définir.
Messages postés
3006
Date d'inscription
dimanche 14 avril 2002
Statut
Membre
Dernière intervention
31 décembre 2008

c'était num == 0, pas nul == 0, désolé.
Messages postés
3006
Date d'inscription
dimanche 14 avril 2002
Statut
Membre
Dernière intervention
31 décembre 2008

À propos du cas de la division par 0 ... je pense que ds énormément de cas le programmeur prend déjà par ailleurs la précaution ailleurs dans son code, et que donc faire ce test est redondant. De plus, dans ta classe tu ne sais pas, a priori, comment gérer l'erreur: déclencher une exception, retourner un vecteur 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF ? (et si tu templatise c'est pas possible), retourner le vecteur nul, allumer un flag erreur static de la classe ... c'est pas pratique. En plus, une division par zéro c'est pas dur à détecter (suffit de mettre ça dans le code:)

#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.
Messages postés
2023
Date d'inscription
mardi 24 septembre 2002
Statut
Membre
Dernière intervention
28 juillet 2008
5
Un conseil, au lieu de ca:
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 ++ :)
Afficher les 15 commentaires

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.