Apa tujuan dari kata kunci "final" di C ++ 11 untuk fungsi?

Apa tujuan finalkata kunci dalam fungsi C ++ 11? Saya memahaminya mencegah overriding fungsi oleh kelas turunan, tetapi jika ini masalahnya, bukankah itu cukup untuk menyatakan sebagai non-virtual finalfungsi Anda ? Apakah ada hal lain yang saya lewatkan di sini?

Apa yang Anda hilang, sebagai idljarn telah disebutkan dalam komentar adalah bahwa jika Anda meng-override fungsi dari kelas dasar, maka Anda tidak mungkin menandainya sebagai non-virtual:

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!
};

• Ini untuk mencegah kelas dari diwarisi. Dari Wikipedia :

  C ++ 11 juga menambahkan kemampuan untuk mencegah pewarisan dari kelas atau hanya mencegah metode utama dalam kelas turunan. Ini dilakukan dengan final pengidentifikasi khusus. Sebagai contoh:

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

• Ini juga digunakan untuk menandai fungsi virtual untuk mencegahnya ditimpa dalam kelas turunan:

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

Wikipedia lebih lanjut membuat poin menarik :

Perhatikan bahwa kata kunci bahasa overridejuga finaltidak. Mereka adalah pengidentifikasi teknis; mereka hanya mendapatkan makna khusus ketika digunakan dalam konteks spesifik itu . Di lokasi lain mana pun, mereka bisa menjadi pengidentifikasi yang valid.

Itu berarti, yang berikut ini diperbolehkan:

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

"final" juga memungkinkan pengoptimalan kompiler untuk mem-bypass panggilan tidak langsung:

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

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

  void Blah( void ) { DoSomething(); }

};

dengan "final", kompiler dapat memanggil CDerived::DoSomething()langsung dari dalam Blah(), atau bahkan inline. Tanpa itu, ia harus menghasilkan panggilan tidak langsung di dalam Blah()karena Blah()dapat disebut di dalam kelas turunan yang telah ditimpa DoSomething().

Tidak ada yang ditambahkan ke aspek semantik "final".

Tapi saya ingin menambahkan komentar chris green bahwa "final" mungkin menjadi teknik optimisasi kompiler yang sangat penting dalam waktu yang tidak begitu lama. Tidak hanya dalam kasus sederhana yang ia sebutkan, tetapi juga untuk hierarki kelas dunia nyata yang lebih kompleks yang dapat "ditutup" oleh "final", sehingga memungkinkan kompiler untuk menghasilkan kode pengiriman yang lebih efisien daripada dengan pendekatan vtable yang biasa.

Salah satu kelemahan utama dari vtables adalah bahwa untuk objek virtual semacam itu (dengan asumsi 64-bit pada CPU Intel khas) pointer saja memakan 25% (8 dari 64 byte) dari garis cache. Dalam jenis aplikasi yang saya sukai untuk menulis, ini sangat menyakitkan. (Dan dari pengalaman saya itu adalah argumen # 1 terhadap C ++ dari sudut pandang kinerja purist, yaitu oleh programmer C.)

Dalam aplikasi yang membutuhkan kinerja ekstrem, yang tidak biasa untuk C ++, ini mungkin memang menjadi luar biasa, tidak perlu untuk menyelesaikan masalah ini secara manual dalam gaya C atau juggling Template aneh.

Teknik ini dikenal sebagai Devirtualization . Suatu istilah yang patut diingat. :-)

Ada sebuah pidato hebat baru-baru ini oleh Andrei Alexandrescu yang menjelaskan bagaimana Anda dapat mengatasi situasi seperti itu hari ini dan bagaimana "final" mungkin menjadi bagian dari penyelesaian kasus serupa "secara otomatis" di masa depan (dibahas dengan pendengar):

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

Final tidak dapat diterapkan pada fungsi non-virtual.

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

Itu tidak akan sangat bermakna untuk dapat menandai metode non-virtual sebagai 'final'. Diberikan

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()akan selalu menelepon A::foo.

Tetapi, jika A :: foo adalah virtual, maka B :: foo akan menimpanya. Ini mungkin tidak diinginkan, dan karenanya masuk akal untuk membuat fungsi virtual menjadi final.

Namun pertanyaannya adalah, mengapa memungkinkan final pada fungsi virtual. Jika Anda memiliki hierarki yang dalam:

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 */ };

Kemudian finalmeletakkan 'lantai' pada seberapa banyak overriding dapat dilakukan. Kelas-kelas lain dapat memperluas A dan B dan menimpa mereka foo, tetapi suatu kelas memperpanjang C maka itu tidak diizinkan.

Jadi mungkin tidak masuk akal untuk membuat foo 'top-level' final, tetapi mungkin masuk akal lebih rendah.

(Saya pikir, ada ruang untuk memperluas kata-kata final dan menimpa ke anggota non-virtual. Mereka akan memiliki arti yang berbeda.)

Kasus penggunaan untuk kata kunci 'final' yang saya sukai adalah sebagai berikut:

// 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 menambahkan maksud eksplisit agar fungsi Anda tidak ditimpa, dan akan menyebabkan kesalahan kompilator jika ini dilanggar:

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

Sebagai kode berdiri, itu mengkompilasi, dan B::foomenimpa A::foo. B::fooomong-omong juga virtual. Namun, jika kita mengubah # 1 menjadi virtual int foo() final, maka ini adalah kesalahan penyusun, dan kami tidak diizinkan untuk menimpanyaA::foo lebih jauh di kelas turunan.

Perhatikan bahwa ini tidak memungkinkan kita untuk "membuka kembali" hierarki baru, yaitu tidak ada cara untuk membuat B::foofungsi baru yang tidak terkait yang dapat secara independen menjadi kepala hirarki virtual baru. Setelah suatu fungsi bersifat final, ia tidak akan pernah dapat dideklarasikan lagi di kelas turunan mana pun.

Kata kunci terakhir memungkinkan Anda untuk mendeklarasikan metode virtual, menimpanya sebanyak N kali, dan kemudian mengamanatkan bahwa 'ini tidak lagi dapat ditimpa'. Ini akan berguna dalam membatasi penggunaan kelas turunan Anda, sehingga Anda dapat mengatakan "Saya tahu kelas super saya memungkinkan Anda menimpa ini, tetapi jika Anda ingin berasal dari saya, Anda tidak bisa!".

struct Foo
{
   virtual void DoStuff();
}

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

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

Seperti yang ditunjukkan poster lainnya, itu tidak dapat diterapkan pada fungsi non-virtual.

Salah satu tujuan dari kata kunci terakhir adalah untuk mencegah pengesampingan metode yang tidak disengaja. Dalam contoh saya, DoStuff () mungkin merupakan fungsi pembantu yang hanya perlu diubah oleh kelas turunan untuk mendapatkan perilaku yang benar. Tanpa akhir, kesalahan tidak akan ditemukan sampai pengujian.

Kata kunci terakhir dalam C ++ ketika ditambahkan ke suatu fungsi, mencegahnya ditimpa oleh kelas dasar. Juga ketika ditambahkan ke kelas mencegah pewarisan jenis apa pun. Pertimbangkan contoh berikut yang menunjukkan penggunaan specifier akhir. Program ini gagal dalam kompilasi.

#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;
}

Juga:

#include <iostream>
class Base final
{
};

class Derived : public Base
{
};

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

Tambahan untuk jawaban Mario Knezović:

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();

Kode di atas menunjukkan teorinya, tetapi tidak benar-benar diuji pada kompiler nyata. Sangat dihargai jika ada yang menempel output yang dibongkar.