fonctions amies (compilation)

Version imprimable

Bonjour à tous !

Je désire créer une classe en redéfinissant l'opérateur d'addition. Je mets donc ceci dans le .h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#include <list>
#include <sstream>
 
using namespace std;
 
 
class BigInt  
{
public:
	BigInt();
	BigInt(const int& n);
	virtual ~BigInt();
 
	BigInt& operator =(const int& n);
	bool operator >(const int& n);
	bool operator >(const BigInt& bi);
 
	friend BigInt operator+(const BigInt& a, const BigInt& b);
 
private:
	list<int> nombre;
};

et dans le .cpp :

Code:

1
2
3
4
5
6
7
8
9
BigInt operator+(const BigInt& a, const BigInt& b) 
{
	BigInt res;
 
	list<int>::const_reverse_iterator it1 = a.nombre.rbegin();
	list<int>::const_reverse_iterator it2 = b.nombre.rbegin();
 
	return res;
}

Lors de la compilation, j'ai l'erreur suivante :

Code:

1
2
D:\mfc\fichusnombres\BigInt.cpp(74) : error C2248: 'nombre' : cannot access private member declared in class 'BigInt'
        D:\mfc\fichusnombres\BigInt.h(21) : see declaration of 'nombre'

Pourtant la fonction est bien déclarée comme amie... que faire ?

09/08/2008, 14h25
Mat007

Salut,

Est-ce que BigInt ne serait pas dans un namespace par hasard ?

MAT.
12/08/2008, 00h03
Obsidian

Citation:

Envoyé par TheShade

Pourtant la fonction est bien déclarée comme amie... que faire ?

En premier lieu, si tu as recours à friend dans un projet élémentaire, c'est probablement que tu t'es trompé quelque part.

Ensuite, si tu utilises l'opérateur + avec deux arguments, c'est pour utiliser la fonction dans l'espace de nommage général, donc il faudrait utiliser l'opérateur de portée :: pour spécifier cette fonction. Dans ton code, tu rends amie une des méthodes de ta classe, ce qui ne sert à rien.

Enfin, si tu veux faire X + Y entre deux BigInt, étant donné que X en est déjà un, « + » est considéré comme une méthode lui appartenant, et Y son unique argument. Moralité, tu vires « friend », tu vires « const Bigint & a », tu fais l'addition entre l'instance de ton objet et « b », et ça devrait fonctionner.
12/08/2008, 11h52
befalimpertinent

Ton exemple devrait marcher. Quel compilateur utilises tu ?

Citation:

En premier lieu, si tu as recours à friend dans un projet élémentaire, c'est probablement que tu t'es trompé quelque part.

Parfois il est utile de faire une opération addition symétrique, une fonction externe à la classe le permet et friend est souvent nécéssaire dans ce cas.
D'ailleurs un des rare cas ou il est techniquement acceptable.

Citation:

Envoyé par Obsidian

Dans ton code, tu rends amie une des méthodes de ta classe

Euh... :roll:

Citation:

Envoyé par Obsidian

Enfin, si tu veux faire X + Y entre deux BigInt, étant donné que X en est déjà un, « + » est considéré comme une méthode lui appartenant, et Y son unique argument.

C'est moi qui ne comprend rien ou c'est toi qui dis n'importe quoi là 8O
Citation:
Envoyé par TheShade
Code:

1 2 3 4 5 6 7 8 9 10 BigInt operator+(const BigInt& a, const BigInt& b) { BigInt res; list<int>::const_reverse_iterator it1 = a.nombre.rbegin(); list<int>::const_reverse_iterator it2 = b.nombre.rbegin(); return res; }
Je ne sais pas où tu veux en venir avec ce code :roll: (bon, peut-être que ce n'est pas le code complet)

Sinon, normalement, si tu déclares un opérateur global ami d'une classe, elle devrait pouvoir accéder à ses membres non-publiques, donc, c'est sûrement autre chose :D

12/08/2008, 12h44
Obsidian

Citation:

Envoyé par befalimpertinent

Parfois il est utile de faire une opération addition symétrique, une fonction externe à la classe le permet et friend est souvent nécéssaire dans ce cas. D'ailleurs un des rare cas ou il est techniquement acceptable.

Je suis d'accord, mais dans le cas présent, il utilise « BigInt & » des deux côtés, alors pourquoi ?
12/08/2008, 12h50
3DArchi

Bonjour,
Avec VC++ Express et gcc (sous windows), chez moi, ton exemple compile parfaitement. La vérité est ailleurs:question:.
12/08/2008, 13h00
Obsidian

Citation:

Envoyé par zabibof

Euh... :roll:
C'est moi qui ne comprend rien ou c'est toi qui dis n'importe quoi là 8O

Erreur de ma part, effectivement. J'avais un peu trop l'habitude d'utiliser l'opérateur de portée pour atteindre d'autres méthodes. À ma décharge, j'ai posté tard et je n'utilise friend que très rarement.

Par contre, reconnais qu'utiliser l'opérateur global pour additionner deux membres d'une même classe n'a aucun intérêt dans le cas présent. Tu n'es pas d'accord ?

peut etre en la declarant avant, pour etre sur que les namespace, etc... convergent

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
BigInt operator+(const BigInt& a, const BigInt& b);
 
class BigInt  
{
public:
	BigInt();
	BigInt(const int& n);
	virtual ~BigInt();
 
	BigInt& operator =(const int& n);
	bool operator >(const int& n);
	bool operator >(const BigInt& bi);
 
	friend BigInt operator+(const BigInt& a, const BigInt& b);
 
private:
	list<int> nombre;
};

12/08/2008, 13h33
zabibof

Citation:

Envoyé par Obsidian

Par contre, reconnais qu'utiliser l'opérateur global pour additionner deux membres d'une même classe n'a aucun intérêt dans le cas présent. Tu n'es pas d'accord ?

Ben non :D , si c'était l'opérateur +=, je serais d'accord. Moi, je surcharge toujours l'opérateur + en global mais bon, à chacun ses méthodes :king:
12/08/2008, 13h34
Noxen
Citation:

Envoyé par Obsidian

En premier lieu, si tu as recours à friend dans un projet élémentaire, c'est probablement que tu t'es trompé quelque part.

Je ne vois pas exactement en quoi ; ça me paraît ici tout à fait cohérent avec ce qu'il développe. L'autre solution serait d'avoir un accesseur à la liste, mais ici je ne crois pas que se serait pertinent.

Citation:

Envoyé par Obsidian

Ensuite, si tu utilises l'opérateur + avec deux arguments, c'est pour utiliser la fonction dans l'espace de nommage général, donc il faudrait utiliser l'opérateur de portée :: pour spécifier cette fonction.

Pourquoi aurait-on besoin de '::' ?

Citation:

Envoyé par Obsidian

Dans ton code, tu rends amie une des méthodes de ta classe, ce qui ne sert à rien.

Laquelle ? La seule fonction amie ici est également la seule fonction qui ne soit pas une méthode de classe, justement.

Citation:

Envoyé par Obsidian

Enfin, si tu veux faire X + Y entre deux BigInt, étant donné que X en est déjà un, « + » est considéré comme une méthode lui appartenant, et Y son unique argument. Moralité, tu vires « friend », tu vires « const Bigint & a », tu fais l'addition entre l'instance de ton objet et « b », et ça devrait fonctionner.

C'est vrai que ça pourrait marcher, mais normalement, on ne fait pas comme ça, pour des questions d'arité, de symétrie ; il y a même, me semble-t-il, tout un paragraphe de la Faq qui y est consacré.

Concrètement, c'est la différence entre 'a+=b, et 'c = a + b'. Dans le premier cas, '+=' peut s'utiliser seul, et a un sens, l'objet 'a' est central dans cette opération. Mais '+' n'a aucun sens seul : on ne fait pas 'a + b', mais 'c = a + b', l'opérateur doit être combiné à autre chose ; de plus, on peut voir que 'a' n'est pas central au traitement, on prend des objets, qui ont la même importance, afin d'en créer un 3ème. D'ailleurs, '+=' renvoie l'objet sur lequel a été effectuée l'opération, alors que '+' renvoie un objet nouveau.

De plus, '+' est définit ici pour des BigInt, mais il pourrait combiner un BigInt et un int. Or, avec '+', tu peux faire 'a + b', mais aussi 'b + a'. Si tu définit 'operator+' en méthode de classe, 'BigInt + int' est correct, mais 'int + BigInt' ne l'est pas, ce qui est opposé au sens intuitif de cet opérateur. D'ailleurs, il faudrait définir les deux fonctions :
Code:

1 2 BigInt operator+(const BigInt& b, int i); BigInt operator+(int i, const BigInt& b);
Par contre, selon ce principe, les opérateurs de comparaison (bool operator <) devraient aussi être des fonctions extérieures, et non des méthodes de classe.

Il y a 2 choses sinon qui me préoccupent :

Code:

virtual ~BigInt();

Est-ce-que l'on doit pouvoir hériter de ta classe ? Je n'en ai pas l'impression, et dans ce cas tu devrais pas mettre le destructeur en virtual.

Code:

list<int> nombre;

Ceci veut dire que tu as fait 'using namespace std;' dans le .h de ta classe, et c'est quelque chose à éviter.

A part ça, je ne comprends pas que ça ne compile pas. Ton code m'a l'air correct, et sur ma machine ça compile sans problème, à mon avis ça doit venir d'autre part 8O .