Einzelne Methoden als friend anderer Klassen deklarieren

Hi,

gibt es die Möglichkeit, dass ich zum Beispiel Klasse B Zugriff auf
die Methode KlasseA.Methode1 gewähre und Klasse C auf KlasseA.Methode2 ?
Also dass ich einzelnde Methoden als friend anderer Klassen mache.

Tachyon

class A
{
public:
    void foo();
    void bar();
};

class B
{
public:
    void foo();
    void bar();
};

class C
{
    int a;
    friend void A::foo();
    friend void B::bar();
};

Ich meine es etwas anders.

class A
{
private:
    void Methode1();
    void Methode2();
};

class B
{
    // Klasse B soll nur A::Methode1() aufrufen dürfen
};

class C
{
    // Klasse C soll nur A::Methode2() aufrufen dürfen
};

Tachyon

Das geht so nicht. Allerdings erscheint mir das auch wenig sinnvoll. Für sowas würde ich eher Interfaces benutzen.

JustAnotherNoob

Berichtigt mich wenn ich Unsinn verzapfe..
Das wäre überhaupt nicht gut, weil deine Klassen dann aneinander gebunden sind.
Im Idealfall sollte deine Klasse aber in jeder Umgebung autonom funktionieren, eine derartige Aufruferbezogenheit reduziert die Wiederverwendbarkeit aber auf ein Minimum.

Nexus

JustAnotherNoob schrieb:

Berichtigt mich wenn ich Unsinn verzapfe..

Stimmt schon.

Klassen sind nicht so konzipiert, dass sie selber auswählen, von wo aus worauf zugegriffen werden kann. Es gibt zwar unterschiedliche Rechte (Zugriffsspezifizierer), aber (mit Ausnahmen der friend s) gelten diese für alle.

Wenn du genauer beschreiben würdest, wozu du diese Einschränkung benötigst, könnten wir dir vielleicht Alternativen nennen.

Ich hatte in der letzten Zeit desöfteren Situationen wo es nützlich wäre.
Zugegebenermaßen waren es glaube ich Designfehler

Hier mal eine.
Ein Object soll nur von einem Manager erstellt werden können.
Daher, alle Constructoren sind private und dann halt eine friend Beziehung.
Nun kann der Manager aber auch auf alle private Sachen zugreifen was ich eg nicht möchte.

ot: Ich bin begeistert wie schnell einem hier geholfen wird

drakon

class A;
class B;

class Manager
{
public:
	A* createA ();
	B* createB ();
};

class A
{
private:
	A ()
	{}
	friend A* Manager::createA();
};

class B
{
private:
	B ()
	{}
	friend B* Manager::createB();
};

cpp:

A* Manager::createA () { 
B b; //uups
return new A;
}

B* Manager::createB () {
A a; //uups 2
return new B; 
}