Bonjour tout le monde,

J'ai débuté il y a peu en C++, et j'essaie de modifier quelques programmes qui marchent pour tester différents trucs. J'en suis à l'apprentissage du fonctionnement des classes, pointeurs, etc...

Là j'ai un programme avec un fichier .h et un fichier .cpp, qui a pour objectif de créer des fonctions qui additionnent, multiplient des vecteurs entre eux.
Je précise que tout fonctionne.

Voici mon .cpp :

#include <iostream>
using namespace std;
#include "vecteur3D.h"

// Définition de la classe


vecteur3D:: vecteur3D(float a, float b,float c)
{
  x=a; y=b; z=c;
}


void vecteur3D::homothetie(float alpha)
{
  x=alpha*x; y=alpha*y; z=alpha*z;
}



vecteur3D vecteur3D::operator+(vecteur3D & V)
{
   return vecteur3D(x+V.x,y+V.y,z+V.z);
}


float operator*(vecteur3D & X,vecteur3D & Y)
{
   return X.x*Y.x+X.y*Y.y+X.z*Y.z;
}


bool operator==(vecteur3D & X,vecteur3D & Y)
{
  return ((X.x==Y.x) && (X.y==Y.y) && (X.z==Y.z));
}

void vecteur3D::affiche()
{
	cout <<x<<"\t"<<y<<"\t"<<z<<"\t";
}

Voici mes questions :

Dans cette partie :
void vecteur3D::homothetie(float alpha) { x=alpha*x; y=alpha*y; z=alpha*z; }

Si à la place de void vecteur3D je mets vecteur3D vecteur3D ça marche aussi. Y a t-il une différence ?

Pourquoi dans operator+ on ne déclare qu'un seul vecteur, alors que dans operator* on en déclare deux ?
J'ai essayé d'en déclarer deux dans operator+ mais ça ne marche pas.

Merci à vous !

Si à la place de void vecteur3D je mets vecteur3D vecteur3D ça marche aussi. Y a t-il une différence ?

ça t'obligera a retourner un Vecteur3D et c'est pas le but de cette fonction

Le 12 octobre 2019 à 12:45:04 mov_eax_1 a écrit :
Si à la place de void vecteur3D je mets vecteur3D vecteur3D ça marche aussi. Y a t-il une différence ?
ça t'obligera a retourner un Vecteur3D et c'est pas le but de cette fonction

Bah pour moi le but de cette fonction c'est de retourner un vecteur3D dont les coefficients ont été multipliés par alpha.

Ca retourne aucun vecteur, ça change les variables x y z du vecteur dans l'instance de la classe.

Les notations d'operateur en C++ sont un peu complique parce qu'il y a plusieurs facon de faire la meme chose.

Basiquement quand tu ecris "x*y" dans le code. Le compilateur interprete ca comme "operator*(x,y)" ou x.operator*(y)"

Dans les deux cas, c'est un appel de fonction, et donc c'est resolu comme un appel de fonction. Note que les type de x et y peuvent etre different. Et que le type de l'expression "x*y" est celui qui est retourne par la foncction operator* avec les parametres qui vont bien.

Du fait, tu peux definir la fonction comme une fonction globale "void operator*(MyObject const & x, MyObject const & y)" ou "MyObject operator*(MyObject & x, MyObject y)", ou comme "Tartenpion operator*(MyObject const & x, MyObject const & y)". Le compilateur prendra le type de retour que tu veux.

En pratique, il est fortement conseiller de n'utiliser que des prototypes qui vont faire ce qu'un utilisateur attend d'un operateur. Pour les operateurs +, -, *, &, &&, etc., le programeur s'attend a ce que les operandes ne changent pas et que l'operateur soit equivalent a un nouvel objet temporaire; donc probablement un prototype:
MyObject operator* (MyObject const& x, MyObject const& y) { /*processing*/ return temp;}

Pour les operateurs qui modifient la valeure du premier argument, comme +=, -= et cie, on s'attend plutot a ce que la valeure de retour soit une reference vers le premier objet
MyObject & operator*= (MyObject & x, MyObject const& y) { /*processing*/ return x;}
Note en passant que le premier parametre est une reference et plus une reference vers un const.

Tu peux faire que les operateurs soit des fonctions membres de l'objet qui est a gauche de l'operateur. Typiquement, les gens utilisent ca pour pouvoir utiliser facilement les variables qui sont encapsuler dans l'objet. Et les prototype sont typiquement:

MyObject MyObject::operator*(MyObject const& y) const {/*processing*/ return temp;}
ou
MyObject& MyObject::operator*= (MyObject const& y) const {/*processing*/ return *this;}

Donc tu peux faire plein d'autre truc. Tu pourrais ecrire un operateur * qui va changer le contenu des deux operandes. Mais ca a l'encontre de toutes les conventions, donc c'est probablement une mauvaise idee.

Salut VDD et merci pour ton message !

Alors justement j'ai essayé de modifier la fonction operator+ afin de faire intervenir une fonction amie, mais j'ai une erreur. En gros j'ai fait ça :

vecteur3D operator+(vecteur3D & X, vecteur3D & Y)
{
return vecteur3D(X.x+Y.x, X.y+Y.y, X.z+Y.z);
}
ensuite dans le .h j'ai déclaré ça :
friend vecteur 3D operator+(vecteur3D &, vecteur3D &);

Le truc c'est que lorsque je veux afficher la somme de deux vecteurs, si j'ai V=(1,2,3) et W=(2,3,4), ça me renvoie (7,0,0)

C'est bon ça marche en fait

Merci à vous en tout cas, surtout au VDD qui m'a bien aidé à résoudre mon problème

J'en profite pour vous reposer une autre question.
Du coup j'aurais aimé modifier la fonction homothetie, de façon à ce qu'elle renvoie un vecteur3D, et non qu'elle modifie les coordonnées dans l'instance comme elle l'a fait là.
J'ai fait ça :

vecteur3D vecteur3D::homothetie(vecteur3D & X, float alpha)
{
  return vecteur3D(X.x * alpha, X.y * alpha, X.z * alpha);
}

Dans le .h :
vecteur3D homothetie(vecteur3D &, float);
Et dans le main j'ai déclaré un vecteur3D V(1,2,3) et quand je fais :

 
V.homothetie(V,4);  // Bon j'avoue que c'est pas très lisible vu comme ça
V.affiche();

ça me renvoie juste V mais sans l'homothétie

Il y a plusieurs chose bizarre dans ce que tu montres. tu as fait homothetie une fonction member de l'objet. Et homothetie est une operation qui ne travail que sur un seul vecteur. Donc pourquoi tu en passe un deuxieme en parametre?

Ensuite ta fonction retourne un vecteur, et ne modifie pas le vecteur sur lequel la fonction est appelle. Donc pourquoi est ce que tu t'attend a ce que V est change quand tu l'affiche?

auto V2 = V.homothetie(V,4);
V2.affiche();

Le 15 octobre 2019 à 07:35:32 TheFearisback a écrit :
auto V2 = V.homothetie(V,4);
V2.affiche();

Je dirais d'éviter "auto" pour ce cas particulier.