Pura funzione virtuale con implementazione

La mia comprensione di base è che non esiste un'implementazione per una pura funzione virtuale, tuttavia, mi è stato detto che potrebbe esserci un'implementazione per pura funzione virtuale.

class A {
public:
    virtual void f() = 0;
};

void A::f() {
    cout<<"Test"<<endl;
}

Il codice sopra è OK?

Qual è lo scopo di renderlo una pura funzione virtuale con un'implementazione?

Una virtualfunzione pura deve essere implementata in un tipo derivato che verrà istanziato direttamente, tuttavia il tipo base può ancora definire un'implementazione. Una classe derivata può chiamare esplicitamente l'implementazione della classe base (se le autorizzazioni di accesso lo consentono) utilizzando un nome con ambito completo (chiamando A::f()nel tuo esempio - if A::f()were publicor protected). Qualcosa di simile a:

class B : public A {

    virtual void f() {
        // class B doesn't have anything special to do for f()
        //  so we'll call A's

        // note that A's declaration of f() would have to be public 
        //  or protected to avoid a compile time problem

        A::f();
    }

};

Il caso d'uso che mi viene in mente è quando c'è un comportamento di default più o meno ragionevole, ma il progettista di classe vuole che quel tipo di comportamento di default venga invocato solo esplicitamente. Può anche essere il caso in cui si desidera che le classi derivate eseguano sempre il proprio lavoro ma che siano anche in grado di chiamare un insieme comune di funzionalità.

Si noti che anche se è consentito dal linguaggio, non è qualcosa che vedo comunemente usato (e il fatto che possa essere fatto sembra sorprendere la maggior parte dei programmatori C ++, anche quelli con esperienza).

Per essere chiari, stai fraintendendo cosa = 0; dopo una funzione virtuale significa.

= 0 indica che le classi derivate devono fornire un'implementazione, non che la classe base non possa fornire un'implementazione.

In pratica, quando si contrassegna una funzione virtuale come pura (= 0), è molto scarso fornire una definizione, perché non verrà mai chiamata a meno che qualcuno non lo faccia esplicitamente tramite Base :: Function (...) o se il Il costruttore della classe base chiama la funzione virtuale in questione.

Il vantaggio è che impone ai tipi derivati ​​di sostituire ancora il metodo ma fornisce anche un'implementazione predefinita o aggiuntiva.

Se si dispone di codice che dovrebbe essere eseguito dalla classe derivante, ma non si desidera che venga eseguito direttamente - e si desidera forzarlo per essere sostituito.

Il tuo codice è corretto, anche se tutto sommato questa non è una funzionalità spesso utilizzata e di solito si vede solo quando si tenta di definire un distruttore virtuale puro, in tal caso è necessario fornire un'implementazione. La cosa divertente è che una volta derivato da quella classe non è necessario scavalcare il distruttore.

Quindi l'unico uso sensato di pure funzioni virtuali è specificare un puro distruttore virtuale come parola chiave "non definitiva".

Il seguente codice è sorprendentemente corretto:

class Base {
public:
  virtual ~Base() = 0;
};

Base::~Base() {}

class Derived : public Base {};

int main() { 
  // Base b; -- compile error
  Derived d; 
}

Dovresti dare un corpo a un puro distruttore virtuale, ad esempio :)

Leggi: http://cplusplus.co.il/2009/08/22/pure-virtual-destructor/

(Collegamento interrotto, utilizzare l'archivio)

Sì questo è corretto. Nel tuo esempio, le classi che derivano da A ereditano sia l'interfaccia f () che un'implementazione predefinita. Ma imponi alle classi derivate di implementare il metodo f () (anche se è solo per chiamare l'implementazione predefinita fornita da A).

Scott Meyers ne discute in Effective C ++ (2nd Edition) Item # 36 Distingue tra eredità dell'interfaccia ed eredità dell'implementazione. Il numero dell'articolo potrebbe essere cambiato nell'ultima edizione.

Le funzioni virtuali pure con o senza un corpo significano semplicemente che i tipi derivati ​​devono fornire la propria implementazione.

I corpi delle funzioni virtuali pure nella classe base sono utili se le classi derivate vogliono chiamare l'implementazione della classe base.

Il 'virtual void foo () = 0;' la sintassi non significa che non puoi implementare foo () nella classe corrente, puoi. Inoltre non significa che è necessario implementarlo in classi derivate . Prima di schiaffeggiarmi, osserviamo il problema del diamante: (codice implicito, intendiamoci).

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

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

class C : public virtual A
{
public:
    void bar();
}

class D : public B, public C
{}

int main(int argc, const char* argv[])
{
    A* obj = new D();
    **obj->foo();**
    return 0;
}

Ora, l'invocazione obj-> foo () si tradurrà in B :: foo () e poi in C :: bar ().

Vedi ... i metodi virtuali puri non devono essere implementati nelle classi derivate (foo () non ha implementazione nella classe C - il compilatore verrà compilato) In C ++ ci sono molte scappatoie.

Spero di poterti aiutare :-)

Un caso d'uso importante di avere un metodo virtuale puro con un corpo di implementazione è quando si desidera avere una classe astratta, ma non si dispone di metodi adeguati nella classe per renderlo puro virtuale. In questo caso, puoi rendere virtuale il distruttore della classe e mettere la tua implementazione desiderata (anche un corpo vuoto) per quello. Come esempio:

class Foo
{
   virtual ~Foo() = 0;
   void bar1() {}
   void bar2(int x) {}
   // other methods
};

Foo::~Foo()
{
}

Questa tecnica rende la Fooclasse astratta e, di conseguenza, impossibile creare un'istanza diretta della classe. Allo stesso tempo non è stato aggiunto un metodo virtuale puro aggiuntivo per rendere Fooastratta la classe.