Discussion :

[Dani3L]

Bonjour

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

J'ai une structure Vector :

Code :

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

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 :

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

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

et voici sa définition :

Code :

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

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 :

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

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

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

[Klaim]

Est-ce que par hasard la déclaration de Vector ne précède pas la déclaration de l'operateur?

[Dani3L]

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

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

Code :

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

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

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

Code :

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

#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 ?

[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?

Ca donnerait:

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
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)

[Dani3L]

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.

[coyotte507]

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 :

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

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 :

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

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 basic_string.h :

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

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.

[Dani3L]

A oui tout ceci était une très bonne idée. Cela marche bien. Merci beaucoup pour votre aide en tous cas.

[Davidbrcz]

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

[coyotte507]

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.

[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.