Discussion :

[monsrhf]

je travail sur un exercice en c++, quand je compile je trouve l'erreur suivante:
in function 'int coincide(vector3d, vector3d)':
error: lvalue required as left operand of assignement

mon code.h est :

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
#ifndef VECTOR3D_H
#define VECTOR3D_H
 
 
class vector3d
{
    float x,y,z;
    public:
        vector3d(float c1,float c2,float c3);
        ~vector3d();
        friend int coincide(vector3d v1,vector3d v2);
    private:
};
 
#endif // VECTOR3D_H

mon code.cpp est comme suit:

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
#include "vector3d.h"
#include <iostream>
 
 
using namespace std;
 
vector3d::vector3d(float c1=0,float c2=0,float c3=0)
{
    x=c1;
    y=c2;
    z=c3;
}
 
vector3d::~vector3d()
{
    //dtor
}
 
int coincide(vector3d v1,vector3d v2)
{
    if(v1.x=v2.x && v1.y=v2.y && v1.z=v2.z)
        return 1;
    else
        return 0;
}

le main.cpp est comme suit:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include "vector3d.h"
 
using namespace std;
 
int main()
{
    vector3d v1(1,3,6);
 
    return 0;
}

[Daïmanu]

Bonsoir.

Je ne sais pas d'où vient précisément le problème, mais il y a plusieurs petites erreurs dans ton code :

Les =0 sont dans la déclaration du constructeur, pas dans son implémentation. Il faut les déplacer.
Il manque le vecteur3d devant coincide() dans le .cpp.
Dans cette fonction coincide() je suppose que tu dois comparer les vecteurs. C'est donc v1.x==v2.x et non v1.x=v2.x. Pareil pour y et z.
Pourquoi ne pas retourner un bool dans la fonction coincide() ? C'est plus approprié et ça permet de raccourcir la fonction :

Code :

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

1
2
3
4
5
 
bool coincide(vector3d v1,vector3d v2)
{
    return (v1.x==v2.x && v1.y==v2.y && v1.z==v2.z);
}

Je pense que c'est le = à la place du == qui cause l'erreur.

Cordialement.

[monsrhf]

merci beaucoup, l'erreur a été corrigée, juste pour la fonction coincide() elle est une fonction amie

friend

donc ce n'est pas nécessaire de citer le type ou la class...

[Daïmanu]

Bonsoir.

la fonction coincide() elle est une fonction amie donc ce n'est pas nécessaire de citer le type ou la class...

En effet, c'est un erreur de ma part, je l'ai corrigé

Si tout est bon, je t'invite à passer le post en

Cordialement.

[prgasp77]

Bonjour monsrhf,

tu aurais gagné du temps si tu avais travaillé avec des objets ou références constants :

Code :

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

1
2
3
4
bool coincide(vector3d const& v1,vector3d const& v2)
{
    return (v1.x==v2.x && v1.y==v2.y && v1.z==v2.z);
}

Compile et fait ce qui est attendu (sans copie de v1 et v2) d'une part et assure d'autre part à l'utilisateur de la fonction que coincide ne fait que lire (et pas modifier) les arguments. De plus, le code qui suit ne compile pas en te disant clairement pourquoi. On gagne du temps au débogage.

Code :

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

1
2
3
4
bool coincide(vector3d const& v1,vector3d const& v2)
{
    return (v1.x=v2.x && v1.y=v2.y && v1.z=v2.z);
}

Cordialement,


EDIT :
Attention aux tests d'égalité avec les flottants. Démonstration :

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
#include <iostream>
 
template<typename F>
F transform(const F f)
{
    F result = f;
    /* ((f + 1) * 2 - 2 ) / 2 == f */
    result += 1.0f;
    result *= 2.0f;
    result -= 2.0f;
    result /= 2.0f;
 
    return result;
}
 
int main(void)
{
    float f = 3.14f;
    double d = 1.618;
    std::cout << "f: " << std::boolalpha << (f == transform<float>(f)) << std::endl;
    std::cout << "d: " << std::boolalpha << (d == transform<double>(d)) << std::endl;
    return 0;
}

Code shell :

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

1
2
3
$ g++ -Wall -Wextra main.cpp -o feq && ./feq
f: false
d: false

f et transform<>(f) sont très proches, mais pas égaux. Il est donc coutume de comparer les flottants à un epsilon près.