Erreur lors de surcharge d'opérateur

Version imprimable

Bonjour

J'ai un petit problème avec la surcharge d'un opérateur.

J'ai une structure Vector :

Code:

1
2
3
4
5
6
7
8
9
10
11
struct Vector {
    private :
        double* tab;                                                      
        int nbComponent;                                                 
 
    public :
        Vector(int n) throw(std::invalid_argument);                                 
        Vector(const Vector& vector);                                               
        virtual ~Vector();  
        ...
};

Voici le prototype de la fonction operator* :

Code:

Vector operator * (double number, const Vector& vector);

et voici sa définition :

Code:

1
2
3
4
5
6
7
8
9
Vector operator * (double number, const Vector& vector) {
    Vector result(vector.getNbComponent());
 
    for (int i=0; i<vector.getNbComponent(); ++i) {
        result.setValue(i, number * vector.getValue(i));
    }
 
    return result;
}

Lors de la compilation, j'obtiens à la ligne de la déclaration du prototype de la fonction operator* l'erreur suivante :

Code:

error: expected constructor, destructor, or type conversion before ‘operator’

D'où pourrait venir cette erreur ?
Merci d'avance de votre aide.

13/09/2008, 21h39
Klaim

Est-ce que par hasard la déclaration de Vector ne précède pas la déclaration de l'operateur?
14/09/2008, 09h47
Dani3L

En fait je crois que je comprends mon problème.

J'ai un fichier functions.h qui contient le prototype :

Code:

Vector operator * (double number, const Vector& vector);

Mais au début de ce fichier functions.h j'ajoute la ligne :

Code:

#include "Vector.h"

afin qu'à l'endroit où ce trouve ce prototype, la structure Vector soit connue. La définition du corps de la fonction se trouve dans le fichier functions.cpp. Mais mon problème est probablement dũ au fait que dans mon fichier Vector.cpp je fait appel à la fonction operator* ci-dessus.

Donc dans mon fichier functions.h, j'inclus Vector.h mais ma function operator* qui n'est pas encore connue à ce moment là est utilisée dans la définition de la classe Vector.

Est-ce que ça pourrait être mon problème ?

Si ton opérateur * est utilisé dans les méthodes de Vector, pourquoi ne le déclares-tu pas directement à l'intérieur de ta classe Vector?

Ca donnerait:

Code:

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
struct Vector {
    private :
        double* tab;                                                      
        int nbComponent;                                                 
 
    public :
        Vector(int n) throw(std::invalid_argument);                                 
        Vector(const Vector& vector);                                               
        virtual ~Vector();  
        Vector operator * (double number);
        ......
};
 
 
/******
 ............
 ******/
 
Vector Vector::operator * (double number) {
    Vector result(getNbComponent());
 
    for (int i=0; i< getNbComponent(); ++i) {
        result.setValue(i, number * getValue(i));
    }
 
    return result;
}

(Pour la fin, je ne suis pas sûr s'il faut placer le Vector:: avant ou après le operator)

14/09/2008, 13h14
Dani3L

Citation:

Envoyé par coyotte507

Si ton opérateur * est utilisé dans les méthodes de Vector, pourquoi ne le déclares-tu pas directement à l'intérieur de ta classe Vector?

Parce que dans ce cas c'est la multiplication d'un Vector par un nombre (méthode que j'ai déjà faite et qui marche) mais moi j'aimerais l'autre sens, c'est-à-dire la multiplication d'un nombre par un Vector (le nombre comme premier terme de la multiplication) et il me semble que l'on ne peut pas faire ceci avec une fonction membre. C'est pourquoi j'utilise une fonction non membre.

J'espère que ce que je dis est juste.

Citation:

Envoyé par Dani3L

Parce que dans ce cas c'est la multiplication d'un Vector par un nombre (méthode que j'ai déjà faite et qui marche) mais moi j'aimerais l'autre sens, c'est-à-dire la multiplication d'un nombre par un Vector (le nombre comme premier terme de la multiplication) et il me semble que l'on ne peut pas faire ceci avec une fonction membre. C'est pourquoi j'utilise une fonction non membre.

J'espère que ce que je dis est juste.

Oui, tu as raison.

Tu peux cependant quand même mettre la fonction dans le fichier Vector.h:
Code:

1 2 3 4 5 6 7 class Vector { friend operator *(int i, Vector &v); ..... }; Vector operator * (int i, Vector &v);
Et la définir dans le fichier vector.cpp.

Si l'opérateur *(int i) existe déjà dans la classe Vector, tu peux même faire:
Code:

1 2 3 4 5 6 7 8 class Vector { ..... }; inline Vector operator * (int i, Vector &v) { return v*i; }
Pour "inverser" le sens.

Ce n'est pas un crime de mettre une fonction non-membre dans un fichier .h, la STL le fait bien, par exemple pour les strings:
Code:

1 2 3 4 5 6 7 8 9 10 /** * @brief Concatenate C string and string. * @param lhs First string. * @param rhs Last string. * @return New string with value of @a lhs followed by @a rhs. */ template<typename _CharT, typename _Traits, typename _Alloc> basic_string<_CharT,_Traits,_Alloc> operator+(const _CharT* __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
Où l'on concatène un const char* et une string, le const char * en premier, et la string en deuxième.

17/09/2008, 19h06
Dani3L

A oui tout ceci était une très bonne idée. Cela marche bien. Merci beaucoup pour votre aide en tous cas.
17/09/2008, 21h36
Davidbrcz

L'opérateur proposé n'est pas const- correct.
Avec un bon compilateur ca plantera.
17/09/2008, 22h24
coyotte507

Citation:

Envoyé par Davidbrcz

L'opérateur proposé n'est pas const- correct.
Avec un bon compilateur ca plantera.

Je reconnais que j'ai oubliés les const, mais je ne vois pas du tout pourquoi ça planterait avec un bon compilateur.
18/09/2008, 20h12
Davidbrcz

Enfin si le code est valide sémantiquement, il compilera.
Mais la compilation plantera dès que tu aura a utiliser l'opérateur avec un objet constant.