Discussion :

[leconteconte]

Bonjour je debute en C++ et là depuis deux jours je traine sur une classe vecteur car quand je lance la compilation il me renvoit l'erreur ci-dessous
g++ -c vecteur.cpp main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
**main.cpp: In function ‘int main(int, char**)’:
main.cpp:12: error: no match for ‘operator=’ in ‘V4 = V1.vecteur::operator%(((const vecteur&)((const vecteur*)(& V2))))’
vecteur.h:17: note: candidates are: vecteur& vecteur::operator=(const vecteur&)**

ci dessous mes trois fichiers ""main.cpp; vecteur.cpp; vecteur.h"
main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include"vecteur.h"
#include<iostream>
#include<string>
 
using namespace std;
 
int main(int argc, char *argv[]){
	vecteur V1(14,12,8);
	vecteur	V2(-15,4,25);
	vecteur V3,V4,V5;
	V3 = V1+V2;
	V4 = V1 % V2;
	V5 = V1^V2;
	cout <<"( "<<V1<<" ) + ( "<<V2<< ")  ( "<<V3<< " )"<< endl;
	cout <<"( "<<V1<<" ) % ( "<<V2<< ")  ( "<<V4<< " )"<< endl;
	cout <<"( "<<V1<<" ) ^ ( "<<V2<< ")  ( "<<V5<< " )"<< endl;
	return 0;
}

vecteur.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
75
76
77
78
79
80
81
#include"vecteur.h"
#include<iostream>
#include<string>
 
using namespace std;
//static nb_pts=0;
vecteur::vecteur(double a, double b, double c){
x=a;y=b;z=c;
//nb_pts++
}
vecteur& vecteur::operator=(vecteur const& v){
	this->x=v.x;
	this->y=v.y;
	this->z=v.z;
	return *this;
}
vecteur::vecteur(vecteur const& v){
	this->x=v.x;
	this->y=v.y;
	this->z=v.z;
}
 
 
 
vecteur::~vecteur(){
//nb_pt--;
}
 
vecteur vecteur::operator+(vecteur const& v){
	vecteur u;
	u.x=v.x+this->x;
	u.y=v.y+this->y;
	u.z=v.z+this->z;
	return u;
}
 
 
vecteur& vecteur::operator+=(vecteur const& v){
	this->x+=v.x;//(*this)+=*this+v;
	this->y+=v.y;
	this->z+=v.z;
	return *this;
}
 
bool vecteur::operator==(vecteur const& v){
	return (this->x==v.x && this->y==v.y && this->z==v.z);
}
 
double vecteur::operator%(vecteur const& v){
	//double res;
	return (this->x*v.x+this->y*v.y+this->z*v.z);
	//return res;
}
 
vecteur& vecteur::operator^(vecteur const& v){
	this->x=(this->y*v.z)-(this->z*v.y);
	this->y=(-this->x*v.z)+(v.x*this->z);
	this->z=(this->x*v.y)-(v.x*this->y);
	return *this;
}
 
bool vecteur::operator||(vecteur const& v){
	vecteur temp;
	temp.x=(this->y*v.z)-(this->z*v.y);
	temp.y=(-this->x*v.z)+(v.x*this->z);
	temp.z=(this->x*v.y)-(v.x*this->y);
	//temp=this->x.operator^(v);
	return (temp.x==v.x && temp.y==v.y && temp.z==v.z);
}
 
//Affichage
 
void vecteur::affiche(ostream& flux) const{
flux << x <<" , " <<y<<" , "<<z<<" , "<<endl;
}
 
//operateur d'injection de flux
ostream& operator<<(ostream& flux, vecteur const& vec){
	vec.affiche(flux);
	return flux;
}

vecteur.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#ifndef DEF_VECTEUR 
#define DEF_VECTEUR
 
#include<iostream>
#include<string>
 
class vecteur{
	private:
	double x,y,z;
	//int static nb_pts;
	public:
	//constructeurs 
	vecteur();
	vecteur(double x,double y,double z);
	vecteur(vecteur const& v);
//operateur arithmetique
vecteur& operator=(vecteur const& v);
double   operator%(vecteur const& v);
vecteur& operator^(vecteur const& v);
vecteur	 operator+(vecteur const& v);
vecteur& operator+=(vecteur const& v);
bool	operator||(vecteur const& v);
 
//operateur de comparaison
bool	 operator==(vecteur const& v);
 
//bool	 operator||(vecteur const& v);
 
 
//affichage
void	affiche(std::ostream& flux) const;
	~vecteur();
};
 
//Opérateur d'injection dans un flux
std::ostream& operator<<(std::ostream& flux, vecteur const& vec);
 
#endif

[Dalini71]

Bonjour,

Dans cette ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
// ...
double   operator%(vecteur const& v);
// ...
V4 = V1 % V2;

Comme on peut le voir, V1 % V2 va te renvoyer un double, et toi tu tentes de l'affecter à ton vecteur, ce qui n'est pas possible (ou alors il faudrait que tu surcharges l'opérateur =).

[leconteconte]

Merci pour ta remarque justement quand tu le dit je me rend compte de mon erreur pour y remedier vu que le type de retour est un "double et non un type vecteur j'ai modirer le type de la variable V4 en double et là le linkage à fontionner (g++ -c vecteur.cpp main.cpp) mais lorsque j'essaie de compiler le fichier vecteur.o generer j'ai l'erreur ci-dessous:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
/usr/lib/gcc/i486-linux-gnu/4.4.5/../../../../lib/crt1.o: In function `_start':
(.text+0x18): undefined reference to `main'
vecteur.o: In function `vecteur::operator+(vecteur const&)':
vecteur.cpp:(.text+0x122): undefined reference to `vecteur::vecteur()'
vecteur.o: In function `vecteur::operator||(vecteur const&)':
vecteur.cpp:(.text+0x2b0): undefined reference to `vecteur::vecteur()'
collect2: ld returned 1 exit status

que faire dans ce cas!!!!!!!
Merci pour ton aide

[Dalini71]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

vecteur.cpp:(.text+0x122): undefined reference to `vecteur::vecteur()

Tu as bien déclaré le prototype de ton constructeur par défaut, mais tu ne l'as pas implémenté, donc forcément ça plante

[leconteconte]

je l'ai implementer après linkage et compilation j'ai l'erreur ci dessous

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
/usr/lib/gcc/i486-linux-gnu/4.4.5/../../../../lib/crt1.o: In function `_start':
(.text+0x18): undefined reference to `main'
collect2: ld returned 1 exit status

Merci pour ton aide

[Dalini71]

J'ai copié-collé ton code est ça marche chez moi.

Ca marche pas avec genre g++ main.cpp vecteur.cpp ?

[leconteconte]

oui pour g++ -c main.cpp vecteur.cpp ça marche mais lorsque que je veux compiler le fichier vecteur.o generer via la commande g++ -o vecteur(executable de sortie) vecteur.o j'ai l'erreur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
/usr/lib/gcc/i486-linux-gnu/4.4.5/../../../../lib/crt1.o: In function `_start':
(.text+0x18): undefined reference to `main'
collect2: ld returned 1 exit status

Merci pour ton aide

[therwald]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

g++ -o vecteur(executable de sortie) vecteur.o

Là il faut aussi main.o, sinon, comme le dit le message d'erreur, le linker ne trouve pas l'implémentation de ta méthode main...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

g++ -o vecteur vecteur.o main.o

[leconteconte]

effectivement il manquait le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

main.o

Merci pour votre aide problème resolu

[3DArchi]

Salut,

Aucun développeur ne saura dire à priori ce que signifie v1%v2, v1^v2 ou encore v1||v2 sans aller regarder l'implémentation effective de ces surcharges... Ces opérateurs on un sens pour les types primitifs. Tu détournes complètement leur sens pour les vecteurs. Cela créé de la confusion. C'est une très mauvaise idée. Tu devrais faire des fonctions au nom explicite (produitVectoriel, produitScalaire,...). Il ne faut pas surcharger des opérateurs avec une sémantique sans rapport de leur sémantique usuelle tout ça parce qu'on pense avoir un (faux) bénéfice syntaxique.

Le constructeur par copie, l'opérateur d'affectation et le destructeurs sont inutiles. Ils sont générés automatiquement par le compilateur et cette version suffit pour une classe ne contenant que des valeurs comme membre. Cf F.A.Q. : Quand dois-je définir un constructeur par copie ?, Quand dois-je définir l'opérateur d'affectation ? et Quand dois-je définir un destructeur ?

Tes constructeurs devraient utiliser des listes d'initialisation plutôt que des initialisations à l'intérieur : Mes constructeurs doivent-ils utiliser les listes d'initialisation ou l'affectation ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
vecteur::vecteur(double a, double b, double c)
:x(a),y(b),z(c)
{}

Tu peux écrire l'opérateur + à partir de += et éviter ainsi de la duplication de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
vecteur vecteur::operator+(vecteur const& v)const{
	vecteur u(*this);
	return u+=v;
}
 
 
vecteur& vecteur::operator+=(vecteur const& v){
	this->x+=v.x;
	this->y+=v.y;
	this->z+=v.z;
	return *this;
}

Mais, ces opérateurs s'écrivent mieux à l'extérieur de la classe (pour des raisons de symétrie surtout s'il peut y avoir des conversions implicites) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
class vecteur
{
public:
vecteur&operator+=(vecteur const&);
};
vecteur operator+(vecteur lhs, vecteur const&rhs); // note le passage par copie du premier argument
 
vecteur vecteur::operator+(vecteur lhs, vecteur const& v)
{
	return lhs+=v;
}

Personnellement, je pense que les fonctions comme affiche ont plus vocation à être à l'extérieur de la classe avec ici une amitié bien méritée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class vecteur
{
friend void	affiche(std::ostream& flux, vecteur const &);
};
// ....
void affiche(ostream& flux, vecteur const &v) {
flux << v.x <<" , " <<v.y<<" , "<<v.z<<" , "<<endl;
}

[gl]

Aucun développeur ne saura dire à priori ce que signifie v1%v2, v1^v2 ou encore v1||v2 sans aller regarder l'implémentation effective de ces surcharges... Ces opérateurs on un sens pour les types primitifs. Tu détournes complètement leur sens pour les vecteurs. Cela créé de la confusion. C'est une très mauvaise idée. Tu devrais faire des fonctions au nom explicite (produitVectoriel, produitScalaire,...). Il ne faut pas surcharger des opérateurs avec une sémantique sans rapport de leur sémantique usuelle tout ça parce qu'on pense avoir un (faux) bénéfice syntaxique.

Globalement d'accord mais j'ajouterais quand même un petit bémol. Il existe au moins un cas où ça ne me choque de s'éloigner de la sémantique des opérateurs sur les types primitifs : l'écriture de DSL lorsque l'on cherche à se rapprocher de la sémantique usuel des opérateurs dans le domaine ciblé et qu'il n'y a pas d'ambiguïté (et si les autres propriétés - associativité, priorité, etc. - des opérateurs entre le C++ et le domaine en question sont compatible bien entendu).

[3DArchi]

l'écriture de DSL lorsque l'on cherche à se rapprocher de la sémantique usuel des opérateurs dans le domaine ciblé.

donc l'opérateur garde la même sémantique que celle que l'utilisateur attend

[gl]

donc l'opérateur garde la même sémantique que celle que l'utilisateur attend

Oui tout à fait, mais elle peut être différente de celle de l'opérateur sur les types primitifs du C++.

Mais effectivement, on reste dans le principe de la moindre surprise.

[Flob90]

@3DArchi: boost::range utilise l'opérateur | pour signifier l'application d'un adaptateur sur un range, et c'est bien plux lissible comme ca qu'en echainant les constructeurs je trouve. Je reste d'accord avec toi sur l'idée de fond, mais sans les proscrire si une utilisation détournée augmente la qualité du code.

[3DArchi]

mais sans les proscrire si une utilisation détournée augmente la qualité du code.

Ce qui est très loin d'être le cas ici. Que peuvent signifier v1%v2, v1||v2, v1^v2, v1*v2 (scalaire ? vectoriel ? autre ?)

[Flob90]

Pour ici je suis assez d'accord

[oodini]

Ce qui est très loin d'être le cas ici. Que peuvent signifier v1%v2, v1||v2, v1^v2, v1*v2 (scalaire ? vectoriel ? autre ?)

Pour moi, c'est assez limpide. Une division de vecteurs (ici modulo) ne peut avoir du sens que pour du membre à membre. Je te renvoie aux opérateurs de std::valarray.
Je regrette d'ailleur que std::vector ne propose pas tous ces opérateurs. Même si cela nécessite une documentation.

[Emmanuel Deloget]

Pour moi, c'est assez limpide. Une division de vecteurs (ici modulo) ne peut avoir du sens que pour du membre à membre. Je te renvoie aux opérateurs de std::valarray.
Je regrette d'ailleur que std::vector ne propose pas tous ces opérateurs. Même si cela nécessite une documentation.

% et / n'ont aucun sens mathématique défini pour les vecteurs. ^ n'est défini qu'en dimension 3 (produit vectoriel). * n'est pas défini.

Si je vois ça dans un code, il se produit deux choses :

1/ je ne sais pas ce que fait, donc je m'inquiète fortement
2/ je prends des dispositions pour que le responsable de ce code soit traîné devant la justice.

Ce n'est pas parce qu'on peut le faire qu'on doit le faire, surtout lorsque des fonctions serait nettement plus explicite.

valarray est un mauvais exemple ici, parce que valarray n'est pas un vecteur, mais un ensemble de valeurs. Du coup, %, /, et les autres opérateurs sont complètement défini puisqu'ils s'appliquent sur chaque élément de l'ensemble. C'est le principe du SIMD

[oodini]

valarray est un mauvais exemple ici, parce que valarray n'est pas un vecteur, mais un ensemble de valeurs. Du coup, %, /, et les autres opérateurs sont complètement défini puisqu'ils s'appliquent sur chaque élément de l'ensemble. C'est le principe du SIMD

C'est également ce que qu'on appelle la programmation vectorielle. Donc, l'utilisation d'un vecteur pour des opérations membre à membre ne me choquerait pas.

[Emmanuel Deloget]

C'est également ce que qu'on appelle la programmation vectorielle. Donc, l'utilisation d'un vecteur pour des opérations membre à membre ne me choquerait pas.

SIMD et programmation vectorielle n'ont strictement rien à voir. SIMD signifie Single Instruction, Multiple Data. Le fait que les data soient considérés comme des vecteurs ou comme des valeurs n'a pas de lien avec le mécanisme. Ce n'est pas parce que MMX ou SSE mixent les deux concepts que les deux concepts sont équivalents.

Si tu utilises MMX pour faire un module valeur par valeur sur un ensemble de 2x4 valeurs, tu auras un résultat attendu et compréhensible. C'est du SIMD.

Si tu utilises MMX pour faire un modulo sur 2 vecteurs de dimension 4, tu fais de la programmation vectorielle et le processeur ne va certainement pas faire ce que tu souhaites faire, puisque l'opération mathématique n'est pas définie.