Cast automatico redux

Question

Dopo che ho incasinato la descrizione del mio post precedente su questo, mi sono seduto e ho provato a trasmettere il mio intento esatto.

Ho una classe chiamata P che svolge uno scopo distinto. Ho anche PW che svolge uno scopo distinto su P. PW non ha variabili membro, solo funzioni membro.

Da questa descrizione assumeresti che il codice seguirà così:

class P
{
public:
    void a( );
};

class PW
{
public:
    PW( const P& p ) : p( p ) { }
    void b( );
    P& p;
};

class C
{
public:
    P GetP( ) const { return p; }   
private:
    P p;
};

// ...
    PW& p = c.GetP( ); // valid
// ...

Tuttavia, ciò comporta un problema. Non posso chiamare le funzioni di P senza indiretta dappertutto.

// ...
    p->p->a( )
// ...

Quello che vorrei fare è chiamare p- > a () e fare in modo che determini automaticamente che vorrei chiamare la funzione membro di P.

Anche avere un membro di PW chiamato a non si ridimensiona davvero - cosa succede se aggiungo (o rimuovo) un'altra funzione a P - questo dovrà essere aggiunto (o rimosso) a PW.

Answer 1

Puoi provare a sovrascrivere operatore * e operatore- > per restituire l'accesso all'elemento incorporato p. Qualcosa del genere potrebbe fare il trucco:

class P
{
  public:
    void a( ) { std::cout << "a" << std::endl; }
};

class PW
{
  public:
    PW(P& p) : p(p) { }

    void b( ) { std::cout << "b" << std::endl; }

    P & operator*()  { return p;  }
    P * operator->() { return &p; }

  private:
    P & p;
};

class C
{
  public:
    P & getP() { return p; }

  private:
    P p;
};


int main()
{
  C c;
  PW pw(c.getP());

  (*pw).a();
  pw->a();
  pw.b();

  return EXIT_SUCCESS;
}

Questo codice viene stampato

a
a
b

Tuttavia, questo metodo può confondere l'utente dalla semantica di operator * e operator- > diventa un po 'incasinato.

Answer 2

Se trasformi P in una superclasse in PW, come hai fatto nella tua domanda precedente, potresti chiamare p- > a () e verrebbe indirizzato alla classe P. Sembra che tu abbia già considerato e rifiutato questo però , a giudicare da questa domanda. Se è così, ti andrebbe di spiegare perché questo non funzionerà per te?

Answer 3

Penso che sia necessario riflettere su quale tipo di relazione esiste tra PW e P.

È una relazione is-a? Sono istanze di istanze PW di P? Quindi avrebbe senso avere l'ereditarietà PW da P.

È una relazione tra due? Quindi dovresti restare con contenimento e sopportare l'inconveniente sintattico.

Per inciso, in genere non è una buona idea esporre un riferimento non const a una variabile membro nell'interfaccia pubblica di una classe.