Podział dostępu do klasy

Witam,
chcę zaprojektować trzy klasy A,B,C w taki sposób, że klasa B może korzystać z całego publicznego interfejsu klasy A, natomiast klasa C mogłaby używać tylko niektórych publicznych metod klasy A. Mam z tym problem, ponieważ nie mogę używać przyjaźni.

Chciałem utworzyć klasę A' dziedziczącą prywatnie po klasie A, i wtedy klasy B,C miałyby wspólny interfejs publiczny w klasie A'. W momencie gdy chciałbym wykonać metodę która miała by być wykonywana tylko przez B, rzutowałbym A' na A, lecz próba przypisania A* a = &b; (gdzie b jest typu A') daje błąd przy kompilacji.

Ma ktoś pomysł jak to zrobić?

Czy musza byc 3 klasy? Czemu nie mozesz uzyc przyjazni? Jezeli nie musza byc trzy klasy to mozesz zrobic wielodziedziczenie lub tworzyc obiekty w tych klasach (jezeli dziedziczenie nie ma sensu), ale architektonicznie to co podam, jest złe

A1
A2
B : A1, A2
C : A1

ale jezeli nie nadaja się klasy do dziedziczenia to w klasie B stworz dwie instacje (a1 a2) a w klasie c zrob jedna instacje C

Co by Ci dalo Twoje rozwiazanie? Chyba nie za bardzo rozumiesz dziedziczenia prywatnego. Jaki blad kompilacji? Pokaz takze kod.

@lukasz93 zasada separacji interfejsów... Jeśli klasa X ma korzystać tylko z niektórych metod interfejsu Y to podziel Y na dwa osobne interfejsy.

Nie mogę tworzyć przyjaźni bo taki jest wymóg prowadzącego... Nie posługuje się biegle dziedziczeniem, znam podstawy, więc proszę o wyrozumiałość.

 #include <iostream>
using namespace std;

class A
{
    protected:
        int val;
    public:
        A():val(0){cout << "wywolano konstruktor\n";}
        void metoda_dla_dla_klasyC(){val = 0;cout << "metoda dla klasy C\n";}
};

class AA: private A
{
    public:
    void metoda_dla_dla_wszystkich(){val++;cout << "metoda dla wszystkich\n";}
};

class B
{
    public:
    bool wykonaj(AA& aa){aa.metoda_dla_dla_wszystkich();}
};

class C: public B
{
    public:
    bool tylko_ja_wywolam(A& a){a.metoda_dla_dla_klasyC();}
};

int main()
{
    AA aa;
    B b;
    C c;

    b.wykonaj(aa);
    c.wykonaj(aa);
    A* a = &aa; //error: 'A' is an inaccessible base of 'AA'|
    c.tylko_ja_wywolam(*a);
}

Może podaj pełną treść polecenia, bo to co jak na razie powiedziałeś brzmi dla mnie wyłącznie jak sztuka dla sztuki.

#include <iostream>

class A {
  public:
    void foo() { std::cout << "foo\n"; }
    void bar() { std::cout << "bar\n"; }
};

class B : public A {
};

class D : A {
  public:
    using A::foo;
};

class C : public D {
};

int main() {
  B b;
  b.foo();
  b.bar();
	
  C c;
  c.foo();
  //c.bar(); metoda bar jest niedostępna na tym poziomie

  return 0;
}

(hardcore)
Przyjaźnie są dla słabych,
prywatne wskaźniki na metody i ich wyciąganie :D

#include <iostream>
using namespace std;

class HUE;
typedef void (HUE::*METHOD)(void);

class HUE{
private:
    void br(){cout << "huehuehue" << endl;}
    METHOD m;
public:
    HUE():m(&HUE::br){}
};

int main(){
    HUE hue;
    METHOD callBr = *((METHOD*)&hue);
    (hue.*callBr)();
    return 0;
}

out:
huehuehue