Was ist der Zweck des Schlüsselworts "final" in C ++ 11 für Funktionen?

Was ist der Zweck des finalSchlüsselworts in C ++ 11 für Funktionen? Ich verstehe, dass es das Überschreiben von Funktionen durch abgeleitete Klassen verhindert, aber wenn dies der Fall ist, reicht es dann nicht aus, Ihre finalFunktionen als nicht virtuell zu deklarieren ? Fehlt mir hier noch etwas?

Was Sie vermissen, wie idljarn bereits in einem Kommentar erwähnt hat, ist, dass Sie eine Funktion aus einer Basisklasse möglicherweise nicht als nicht virtuell markieren können , wenn Sie sie überschreiben :

struct base {
   virtual void f();
};
struct derived : base {
   void f() final;       // virtual as it overrides base::f
};
struct mostderived : derived {
   //void f();           // error: cannot override!
};

• Es soll verhindern, dass eine Klasse vererbt wird. Aus Wikipedia :

  C ++ 11 bietet außerdem die Möglichkeit, das Erben von Klassen oder das Überschreiben von Methoden in abgeleiteten Klassen zu verhindern. Dies erfolgt mit der speziellen Kennung final. Beispielsweise:

  struct Base1 final { };
  
  struct Derived1 : Base1 { }; // ill-formed because the class Base1 
                               // has been marked final

• Es wird auch verwendet, um eine virtuelle Funktion zu markieren, um zu verhindern, dass sie in den abgeleiteten Klassen überschrieben wird:

  struct Base2 {
      virtual void f() final;
  };
  
  struct Derived2 : Base2 {
      void f(); // ill-formed because the virtual function Base2::f has 
                // been marked final
  };

Wikipedia macht weiter einen interessanten Punkt :

Beachten Sie, dass weder Sprachschlüsselwörter overridenoch finalSprachschlüsselwörter vorhanden sind. Sie sind technisch identifizierend; Sie erhalten nur dann eine besondere Bedeutung, wenn sie in diesen spezifischen Kontexten verwendet werden . An jedem anderen Ort können sie gültige Bezeichner sein.

Das heißt, Folgendes ist zulässig:

int const final = 0;     // ok
int const override = 1;  // ok

"final" ermöglicht es einer Compileroptimierung auch, den indirekten Aufruf zu umgehen:

class IAbstract
{
public:
  virtual void DoSomething() = 0;
};

class CDerived : public IAbstract
{
  void DoSomething() final { m_x = 1 ; }

  void Blah( void ) { DoSomething(); }

};

Mit "final" kann der Compiler CDerived::DoSomething()direkt von innen Blah()oder sogar inline aufrufen . Ohne sie muss ein indirekter Aufruf innerhalb von generiert werden, Blah()da Blah()er innerhalb einer abgeleiteten Klasse aufgerufen werden kann, die überschrieben wurde DoSomething().

Den semantischen Aspekten von "final" gibt es nichts hinzuzufügen.

Aber ich möchte zu Chris Green's Kommentar hinzufügen, dass "final" in nicht allzu ferner Zukunft eine sehr wichtige Compiler-Optimierungstechnik werden könnte. Nicht nur in dem von ihm erwähnten einfachen Fall, sondern auch für komplexere reale Klassenhierarchien, die durch "final" "geschlossen" werden können, wodurch Compiler einen effizienteren Dispatching-Code generieren können als mit dem üblichen vtable-Ansatz.

Ein wesentlicher Nachteil von vtables besteht darin, dass für ein solches virtuelles Objekt (unter der Annahme von 64 Bit auf einer typischen Intel-CPU) der Zeiger allein 25% (8 von 64 Byte) einer Cache-Zeile verbraucht. Bei den Bewerbungen, die ich gerne schreibe, tut das sehr weh. (Und meiner Erfahrung nach ist es aus puristischer Sicht das wichtigste Argument gegen C ++, dh von C-Programmierern.)

In Anwendungen, die extreme Leistung erfordern, was für C ++ nicht so ungewöhnlich ist, kann dies in der Tat fantastisch werden, da dieses Problem nicht manuell im C-Stil oder durch seltsames Vorlagen-Jonglieren umgangen werden muss.

Diese Technik ist als Devirtualisierung bekannt . Ein Begriff, an den man sich erinnern sollte. :-)

Es gibt eine großartige Rede von Andrei Alexandrescu, die ziemlich gut erklärt, wie Sie solche Situationen heute umgehen können und wie "final" dazu beitragen könnte, ähnliche Fälle "automatisch" in Zukunft zu lösen (mit den Zuhörern besprochen):

http://channel9.msdn.com/Events/GoingNative/2013/Writing-Quick-Code-in-Cpp-Quickly

Final kann nicht auf nicht virtuelle Funktionen angewendet werden.

error: only virtual member functions can be marked 'final'

Es wäre nicht sehr sinnvoll, eine nicht virtuelle Methode als "endgültig" markieren zu können. Gegeben

struct A { void foo(); };
struct B : public A { void foo(); };
A * a = new B;
a -> foo(); // this will call A :: foo anyway, regardless of whether there is a B::foo

a->foo()wird immer anrufen A::foo.

Aber wenn A virtual:: foo wäre, würde B :: foo es überschreiben. Dies könnte unerwünscht sein, und daher wäre es sinnvoll, die virtuelle Funktion endgültig zu machen.

Die Frage ist jedoch, warum endgültige virtuelle Funktionen zulässig sind. Wenn Sie eine tiefe Hierarchie haben:

struct A            { virtual void foo(); };
struct B : public A { virtual void foo(); };
struct C : public B { virtual void foo() final; };
struct D : public C { /* cannot override foo */ };

Dann finallegt das einen "Boden" fest, wie viel Überschreiben getan werden kann. Andere Klassen können A und B erweitern und ihre überschreiben foo, aber wenn eine Klasse C erweitert, ist dies nicht zulässig.

Es macht also wahrscheinlich keinen Sinn, das "Top-Level" -Foo zu machen final, aber es könnte weiter unten Sinn machen.

(Ich denke jedoch, dass es Raum gibt, die Wörter final zu erweitern und auf nicht virtuelle Mitglieder zu überschreiben. Sie hätten jedoch eine andere Bedeutung.)

Ein Anwendungsfall für das Schlüsselwort 'final', das mir gefällt, lautet wie folgt:

// This pure abstract interface creates a way
// for unit test suites to stub-out Foo objects
class FooInterface
{
public:
   virtual void DoSomething() = 0;
private:
   virtual void DoSomethingImpl() = 0;
};

// Implement Non-Virtual Interface Pattern in FooBase using final
// (Alternatively implement the Template Pattern in FooBase using final)
class FooBase : public FooInterface
{
public:
    virtual void DoSomething() final { DoFirst(); DoSomethingImpl(); DoLast(); }
private:
    virtual void DoSomethingImpl() { /* left for derived classes to customize */ }
    void DoFirst(); // no derived customization allowed here
    void DoLast(); // no derived customization allowed here either
};

// Feel secure knowing that unit test suites can stub you out at the FooInterface level
// if necessary
// Feel doubly secure knowing that your children cannot violate your Template Pattern
// When DoSomething is called from a FooBase * you know without a doubt that
// DoFirst will execute before DoSomethingImpl, and DoLast will execute after.
class FooDerived : public FooBase
{
private:
    virtual void DoSomethingImpl() {/* customize DoSomething at this location */}
};

final Fügt eine explizite Absicht hinzu, Ihre Funktion nicht überschreiben zu lassen, und verursacht einen Compilerfehler, falls dies verletzt wird:

struct A {
    virtual int foo(); // #1
};
struct B : A {
    int foo();
};

In der jetzigen Form wird der Code kompiliert und B::fooüberschrieben A::foo. B::fooist übrigens auch virtuell. Wenn wir jedoch # 1 in ändern virtual int foo() final, ist dies ein Compilerfehler, und wir dürfen A::fooin abgeleiteten Klassen nicht weiter überschreiben .

Beachten Sie, dass wir dadurch eine neue Hierarchie nicht "wieder öffnen" können, dh es gibt keine Möglichkeit, B::fooeine neue, nicht verwandte Funktion zu erstellen, die unabhängig an der Spitze einer neuen virtuellen Hierarchie stehen kann. Sobald eine Funktion endgültig ist, kann sie in keiner abgeleiteten Klasse mehr deklariert werden.

Mit dem letzten Schlüsselwort können Sie eine virtuelle Methode deklarieren, N-mal überschreiben und dann festlegen, dass dies nicht mehr überschrieben werden kann. Es wäre nützlich, um die Verwendung Ihrer abgeleiteten Klasse einzuschränken, damit Sie sagen können: "Ich weiß, dass Sie mit meiner Superklasse dies überschreiben können, aber wenn Sie von mir ableiten möchten, können Sie das nicht!".

struct Foo
{
   virtual void DoStuff();
}

struct Bar : public Foo
{
   void DoStuff() final;
}

struct Babar : public Bar
{
   void DoStuff(); // error!
}

Wie andere Poster betonten, kann es nicht auf nicht virtuelle Funktionen angewendet werden.

Ein Zweck des endgültigen Schlüsselworts besteht darin, ein versehentliches Überschreiben einer Methode zu verhindern. In meinem Beispiel war DoStuff () möglicherweise eine Hilfsfunktion, die die abgeleitete Klasse einfach umbenennen muss, um ein korrektes Verhalten zu erzielen. Ohne final würde der Fehler erst beim Testen entdeckt.

Das letzte Schlüsselwort in C ++ verhindert beim Hinzufügen zu einer Funktion, dass diese von einer Basisklasse überschrieben wird. Auch beim Hinzufügen zu einer Klasse wird die Vererbung jeglicher Art verhindert. Betrachten Sie das folgende Beispiel, das die Verwendung des endgültigen Spezifizierers zeigt. Dieses Programm schlägt bei der Kompilierung fehl.

#include <iostream>
using namespace std;

class Base
{
  public:
  virtual void myfun() final
  {
    cout << "myfun() in Base";
  }
};
class Derived : public Base
{
  void myfun()
  {
    cout << "myfun() in Derived\n";
  }
};

int main()
{
  Derived d;
  Base &b = d;
  b.myfun();
  return 0;
}

Ebenfalls:

#include <iostream>
class Base final
{
};

class Derived : public Base
{
};

int main()
{
  Derived d;
  return 0;
}

Ergänzung zu Mario Knezovićs Antwort:

class IA
{
public:
  virtual int getNum() const = 0;
};

class BaseA : public IA
{
public:
 inline virtual int getNum() const final {return ...};
};

class ImplA : public BaseA {...};

IA* pa = ...;
...
ImplA* impla = static_cast<ImplA*>(pa);

//the following line should cause compiler to use the inlined function BaseA::getNum(), 
//instead of dynamic binding (via vtable or something).
//any class/subclass of BaseA will benefit from it

int n = impla->getNum();

Der obige Code zeigt die Theorie, wurde jedoch nicht auf echten Compilern getestet. Sehr geschätzt, wenn jemand eine zerlegte Ausgabe einfügt.