Discussion :

[Klaim]

Je sais que ce n'est pas possible, mais il m'arrive (quand je design certain type de systeme de classes) d'avoir envie qu'une seule et unique fonction de ma classe A soit accessible soit par une autre classe soit par une fonction spécifique. Si je me trompe pas, en c++ c'est impossible.

Exemple :

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
 
class A;
 
class B
{
public:
 
	A* generateA();
 
};
 
 
class A
{
private:
 
	A() {
 
	}
 
};
 
A* B::generateA()
{
	return new A;
}
 
 
int main()
{
	B test;
 
	A* a = test.generateA();
 
	return 0;
}

Ne compile pas puisque le constructeur de A est privé.
La seule solution c'est d'utiliser friend soit pour rendre accessible toute la classe A à toutes les methodes de B, soit uniquement a une methode de B : B::generateA() :

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
 
class A;
 
class B
{
public:
 
	A* generateA();
 
};
 
 
class A
{
private:
 
	friend A* B::generateA();
 
	A() {
 
	}
 
};
 
A* B::generateA()
{
	return new A;
}
 
 
int main()
{
	B test;
 
	A* a = test.generateA();
 
	return 0;
}

Ca compile.


Je ne vois aucun moyen de faire ce dont je parlais au départ , qui reviendrait à avoir quelque chose comme un "friend" mais déclaré uniquement pour une méthode de A, pas pour toute la classe, comme par exemple (fictif) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class A
{
private:
 
 
	A() friend A* B::generateA() {
 
	}
 
 
 
};

Qui indiquerait donc que le constructeur pourrait être appelé uniquement par la methode B::generateA() .


Maintenant les questions :

0) Ai-je faux? - je demande juste au cas où ya une règle planquée qui permet ça mais que j'ai pas trouvé dans les docs c++... normalement friend n'est possible que dans la déclaration d'une classe.

1) Est-ce qu'il existe un moyen détourné de faire ce que je veux? (j'en doute...)

2) Est-ce qu'il y a une raison purement théorique dans le langage qui fait que cette "feature" n'est pas possible? (c'est là ou je veux en venir)

[buggen25]

salut;
c'est tres interessant ton truc
On peut ignorer les droit acces de type public, private, ou protected par un caste explicite à la dure
http://www.developpez.net/forums/d63...ion-pointeurs/
Je crois qu'on peut tout faire avec c++

[r0d]

0) Ai-je faux? - je demande juste au cas où ya une règle planquée qui permet ça mais que j'ai pas trouvé dans les docs c++... normalement friend n'est possible que dans la déclaration d'une classe.

Sauf erreur de ma part, tu as raison.

1) Est-ce qu'il existe un moyen détourné de faire ce que je veux? (j'en doute...)

J'en vois un, mais je ne suis pas sûr que ce soit une bonne idée. Ce serait une variation sur le pattern template method. En fait, la fonction que tu veux mettre en amie et/ou celle dont une autre sera l'amie, tu la met dans une classe, dont une instance sera membre de ou des classe(s) souhaitée(s). Une classe avec une seule fonction.

2) Est-ce qu'il y a une raison purement théorique dans le langage qui fait que cette "feature" n'est pas possible? (c'est là ou je veux en venir)

Joker! (nan sérieusement, je n'en sais rien).

[Klaim]

Ok, j'ai beau chercher une bonne raison je ne trouve rien qui l'empêcherai...

Je vais jetter un oeil dans les docs des propositions pour les futurs standards voir si ça n'avait pas été proposé.

[Luc Hermitte]

En jouant avec les héritages, l'amitié sélective est réalisable.
Maintenant, l'intérêt ....

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
//vieux code
/** But : tester comment mettre en oeuvre une amitié sélective.
 * ie.: faire en sorte qu'un membre m_i ne soit accessible qu'à une
 * seule fonction f_i()
 */
 
#include <iostream>
#include <string>
using namespace std;
 
template <class T> void f1(T&t) { cout << t.m1() << endl; }
// template <class T> void f2(T&t) { cout << t.m2() << endl; }
template <class T> void f2(T&t) { cout << t.m1() << t.m2() << endl; }
template <class R> void f1bis(R&t) { cout << t.m1() << endl; }
 
 
struct empty {};
 
template <class Super>
class Role1 : public Super
{
    template <class T> friend void f1(T&t);
    friend void f1bis<>(Role1&);
    const string m1() { return "Méthode 1"; }
};
 
template <class Super>
class Role2 : public Super
{
    template <class T> friend void f2(T&t);
    const string m2() { return "Méthode 2"; }
};
 
 
typedef Role1<Role2<empty> > TYPE;
 
 
int main (int argc, char **argv)
{
    TYPE toto;
    f1(toto);
    f1bis(toto);
    f2(toto);
}

[Alp]

Des Mixin Layers version allégée ?

[coyotte507]

Généralement, si on laisse l'autorisation à une fonction d'accéder à un membre private, c'est une fonction qui fait partie du module, en relation étroite avec la classe, et le programmeur sait alors ce qu'il fait...

A mon avis c'est pour ça qu'il n'y a pas besoin de rajouter des restrictions au mot-clé "friend".