C ++ anggota virtual statis?

Apakah mungkin dalam C ++ untuk memiliki fungsi anggota yang keduanya staticdan virtual? Rupanya, tidak ada cara langsung untuk melakukannya (static virtual member(); adalah kesalahan kompilasi), tetapi apakah ada setidaknya cara untuk mencapai efek yang sama?

YAITU:

struct Object
{
     struct TypeInformation;

     static virtual const TypeInformation &GetTypeInformation() const;
};

struct SomeObject : public Object
{
     static virtual const TypeInformation &GetTypeInformation() const;
};

Masuk akal untuk menggunakan GetTypeInformation()keduanya pada instance ( object->GetTypeInformation()) dan pada kelas (SomeObject::GetTypeInformation() ), yang dapat berguna untuk perbandingan dan penting untuk template.

Satu-satunya cara yang dapat saya pikirkan adalah menulis dua fungsi / fungsi dan konstanta, per kelas, atau menggunakan makro.

Ada solusi lain?

Tidak, tidak ada cara untuk melakukannya, karena apa yang akan terjadi ketika Anda menelepon Object::GetTypeInformation()? Itu tidak bisa tahu versi kelas turunan mana untuk memanggil karena tidak ada objek yang terkait dengannya.

Anda harus menjadikannya fungsi virtual non-statis agar berfungsi dengan baik; jika Anda juga ingin dapat memanggil versi kelas turunan tertentu secara non-virtual tanpa instance objek, Anda juga harus menyediakan versi non-virtual statis redundan kedua.

Banyak yang mengatakan itu tidak mungkin, saya akan melangkah lebih jauh dan mengatakan itu tidak berarti.

Anggota statis adalah sesuatu yang tidak berhubungan dengan instance apa pun, hanya untuk kelas.

Anggota virtual adalah sesuatu yang tidak berhubungan langsung dengan kelas mana pun, hanya dengan sebuah instance.

Jadi anggota virtual statis akan menjadi sesuatu yang tidak berhubungan dengan instance atau kelas apa pun.

Saya mengalami masalah ini beberapa hari yang lalu: Saya memiliki beberapa kelas yang penuh dengan metode statis tetapi saya ingin menggunakan metode pewarisan dan virtual dan mengurangi pengulangan kode. Solusi saya adalah:

Alih-alih menggunakan metode statis, gunakan singleton dengan metode virtual.

Dengan kata lain, setiap kelas harus berisi metode statis yang Anda panggil untuk mendapatkan pointer ke instance kelas yang dibagi bersama. Anda dapat menjadikan konstruktor yang sebenarnya privat atau terlindungi sehingga kode luar tidak dapat menyalahgunakannya dengan membuat instance tambahan.

Dalam praktiknya, menggunakan singleton sangat mirip dengan menggunakan metode statis kecuali bahwa Anda dapat mengambil keuntungan dari metode pewarisan dan virtual.

Itu mungkin!

Tapi apa sebenarnya yang mungkin, mari kita persempit. Orang sering menginginkan semacam "fungsi virtual statis" karena duplikasi kode yang diperlukan untuk dapat memanggil fungsi yang sama melalui panggilan statis "SomeDerivedClass :: myfunction ()" dan panggilan polimorf "base_class_pointer-> myfunction ()". Metode "Legal" untuk mengizinkan fungsi seperti itu adalah duplikasi definisi fungsi:

class Object
{
public:
    static string getTypeInformationStatic() { return "base class";}
    virtual string getTypeInformation() { return getTypeInformationStatic(); }
}; 
class Foo: public Object
{
public:
    static string getTypeInformationStatic() { return "derived class";}
    virtual string getTypeInformation() { return getTypeInformationStatic(); }
};

Bagaimana jika kelas dasar memiliki sejumlah besar fungsi statis dan kelas turunan harus menimpanya masing-masing dan orang lupa untuk memberikan definisi duplikat untuk fungsi virtual. Benar, kami akan mendapatkan beberapa kesalahan aneh saat runtime yang sulit dilacak. Menyebabkan duplikasi kode adalah hal yang buruk. Berikut ini mencoba untuk menyelesaikan masalah ini (dan saya ingin memberitahu sebelumnya bahwa itu benar-benar aman dan tidak mengandung ilmu hitam seperti typeid atau dynamic_cast :)

Jadi, kami ingin memberikan hanya satu definisi getTypeInformation () per kelas turunan dan jelas bahwa itu harus merupakan definisi dari statisberfungsi karena tidak mungkin untuk memanggil "SomeDerivedClass :: getTypeInformation ()" jika getTypeInformation () adalah virtual. Bagaimana kita bisa memanggil fungsi statis dari kelas turunan melalui pointer ke kelas dasar? Tidak mungkin dengan vtable karena vtable hanya menyimpan pointer ke fungsi virtual dan karena kami memutuskan untuk tidak menggunakan fungsi virtual, kami tidak dapat memodifikasi vtable untuk keuntungan kami. Kemudian, untuk dapat mengakses fungsi statis untuk kelas turunan melalui pointer ke kelas dasar kita harus menyimpan entah bagaimana jenis objek di dalam kelas dasarnya. Salah satu pendekatannya adalah membuat kelas dasar di-templatized menggunakan "pola templat berulang-ulang yang anehnya" tetapi tidak sesuai di sini dan kami akan menggunakan teknik yang disebut "type erasure":

class TypeKeeper
{
public:
    virtual string getTypeInformation() = 0;
};
template<class T>
class TypeKeeperImpl: public TypeKeeper
{
public:
    virtual string getTypeInformation() { return T::getTypeInformationStatic(); }
};

Sekarang kita dapat menyimpan jenis objek dalam kelas dasar "Object" dengan variabel "keeper":

class Object
{
public:
    Object(){}
    boost::scoped_ptr<TypeKeeper> keeper;

    //not virtual
    string getTypeInformation() const 
    { return keeper? keeper->getTypeInformation(): string("base class"); }

};

Dalam penjaga kelas turunan harus diinisialisasi selama konstruksi:

class Foo: public Object
{
public:
    Foo() { keeper.reset(new TypeKeeperImpl<Foo>()); }
    //note the name of the function
    static string getTypeInformationStatic() 
    { return "class for proving static virtual functions concept"; }
};

Mari kita tambahkan gula sintaksis:

template<class T>
void override_static_functions(T* t)
{ t->keeper.reset(new TypeKeeperImpl<T>()); }
#define OVERRIDE_STATIC_FUNCTIONS override_static_functions(this)

Sekarang deklarasi keturunan terlihat seperti:

class Foo: public Object
{
public:
    Foo() { OVERRIDE_STATIC_FUNCTIONS; }
    static string getTypeInformationStatic() 
    { return "class for proving static virtual functions concept"; }
};

class Bar: public Foo
{
public:
    Bar() { OVERRIDE_STATIC_FUNCTIONS; }
    static string getTypeInformationStatic() 
    { return "another class for the same reason"; }
};

pemakaian:

Object* obj = new Foo();
cout << obj->getTypeInformation() << endl;  //calls Foo::getTypeInformationStatic()
obj = new Bar();
cout << obj->getTypeInformation() << endl;  //calls Bar::getTypeInformationStatic()
Foo* foo = new Bar();
cout << foo->getTypeInformation() << endl; //calls Bar::getTypeInformationStatic()
Foo::getTypeInformation(); //compile-time error
Foo::getTypeInformationStatic(); //calls Foo::getTypeInformationStatic()
Bar::getTypeInformationStatic(); //calls Bar::getTypeInformationStatic()

Keuntungan:

1. lebih sedikit duplikasi kode (tetapi kami harus memanggil OVERRIDE_STATIC_FUNCTIONS di setiap konstruktor)

Kekurangan:

1. OVERRIDE_STATIC_FUNCTIONS di setiap konstruktor
2. memori dan overhead kinerja
3. peningkatan kompleksitas

Masalah terbuka:

1) ada berbagai nama untuk fungsi statis dan virtual cara mengatasi ambiguitas di sini?

class Foo
{
public:
    static void f(bool f=true) { cout << "static";}
    virtual void f() { cout << "virtual";}
};
//somewhere
Foo::f(); //calls static f(), no ambiguity
ptr_to_foo->f(); //ambiguity

2) bagaimana cara memanggil OVERRIDE_STATIC_FUNCTIONS secara implisit di dalam setiap konstruktor?

Sementara Alsk telah memberikan jawaban yang cukup terperinci, saya ingin menambahkan alternatif, karena saya pikir penerapannya yang disempurnakan terlalu rumit.

Kita mulai dengan kelas dasar abstrak, yang menyediakan antarmuka untuk semua jenis objek:

class Object
{
public:
    virtual char* GetClassName() = 0;
};

Sekarang kita membutuhkan implementasi yang sebenarnya. Tetapi untuk menghindari keharusan menulis metode statis dan virtual, kita akan meminta kelas objek aktual kita mewarisi metode virtual. Ini jelas hanya berfungsi, jika kelas dasar tahu bagaimana mengakses fungsi anggota statis. Jadi kita perlu menggunakan templat dan meneruskan nama kelas objek aktual ke sana:

template<class ObjectType>
class ObjectImpl : public Object
{
public:
    virtual char* GetClassName()
    {
        return ObjectType::GetClassNameStatic();
    }
};

Akhirnya kita perlu mengimplementasikan objek nyata kita. Di sini kita hanya perlu mengimplementasikan fungsi anggota statis, fungsi anggota virtual akan diwarisi dari kelas templat ObjectImpl, dipakai dengan nama kelas turunan, sehingga akan mengakses anggota statis itu.

class MyObject : public ObjectImpl<MyObject>
{
public:
    static char* GetClassNameStatic()
    {
        return "MyObject";
    }
};

class YourObject : public ObjectImpl<YourObject>
{
public:
    static char* GetClassNameStatic()
    {
        return "YourObject";
    }
};

Mari tambahkan beberapa kode untuk diuji:

char* GetObjectClassName(Object* object)
{
    return object->GetClassName();
}

int main()
{
    MyObject myObject;
    YourObject yourObject;

    printf("%s\n", MyObject::GetClassNameStatic());
    printf("%s\n", myObject.GetClassName());
    printf("%s\n", GetObjectClassName(&myObject));
    printf("%s\n", YourObject::GetClassNameStatic());
    printf("%s\n", yourObject.GetClassName());
    printf("%s\n", GetObjectClassName(&yourObject));

    return 0;
}

Tambahan (12 Januari 2019):

Alih-alih menggunakan fungsi GetClassNameStatic (), Anda juga dapat mendefinisikan nama kelas sebagai anggota statis, bahkan "inline", yang bekerja IIRC sejak C ++ 11 (jangan takut oleh semua pengubah :)):

class MyObject : public ObjectImpl<MyObject>
{
public:
    // Access this from the template class as `ObjectType::s_ClassName` 
    static inline const char* const s_ClassName = "MyObject";

    // ...
};

Itu mungkin. Buat dua fungsi: statis dan virtual

struct Object{     
  struct TypeInformation;
  static  const TypeInformation &GetTypeInformationStatic() const 
  { 
      return GetTypeInformationMain1();
  }
  virtual const TypeInformation &GetTypeInformation() const
  { 
      return GetTypeInformationMain1();
  }
protected:
  static const TypeInformation &GetTypeInformationMain1(); // Main function
};

struct SomeObject : public Object {     
  static  const TypeInformation &GetTypeInformationStatic() const 
  { 
      return GetTypeInformationMain2();
  }
  virtual const TypeInformation &GetTypeInformation() const
  { 
      return GetTypeInformationMain2();
  }
protected:
  static const TypeInformation &GetTypeInformationMain2(); // Main function
};

Tidak, ini tidak mungkin, karena fungsi anggota statis tidak memiliki thispointer. Dan anggota statis (baik fungsi dan variabel) tidak benar-benar anggota kelas per-se. Mereka kebetulan dipanggil oleh ClassName::member, dan mematuhi penentu akses kelas. Penyimpanan mereka didefinisikan di suatu tempat di luar kelas; penyimpanan tidak dibuat setiap kali Anda membuat objek kelas. Pointer ke anggota kelas khusus dalam semantik dan sintaksis. Pointer ke anggota statis adalah pointer normal dalam semua hal.

fungsi virtual di kelas membutuhkan thispointer, dan sangat digabungkan ke kelas, karenanya mereka tidak bisa statis.

Yah, jawaban yang agak terlambat tetapi mungkin menggunakan pola templat berulang yang aneh. Ini wikipedia artikel memiliki info yang Anda butuhkan dan juga contoh di bawah statis polimorfisme adalah apa yang Anda minta.

Saya pikir apa yang Anda coba lakukan dapat dilakukan melalui template. Saya mencoba membaca yang tersirat di sini. Apa yang Anda coba lakukan adalah memanggil metode dari beberapa kode, di mana ia memanggil versi turunan tetapi pemanggil tidak menentukan kelas mana. Contoh:

class Foo {
public:
    void M() {...}
};

class Bar : public Foo {
public:
    void M() {...}
};

void Try()
{
    xxx::M();
}

int main()
{
    Try();
}

Anda ingin Try () memanggil versi Bar M tanpa menentukan Bar. Cara Anda melakukannya untuk statika adalah dengan menggunakan templat. Jadi ubah seperti ini:

class Foo {
public:
    void M() {...}
};

class Bar : public Foo {
public:
    void M() {...}
};

template <class T>
void Try()
{
    T::M();
}

int main()
{
    Try<Bar>();
}

Tidak, fungsi anggota statis tidak boleh virtual. Karena konsep virtual diselesaikan pada saat dijalankan dengan bantuan vptr, dan vptr bukan anggota statis suatu kelas. Karena fungsi anggota statis tidak dapat mengakses vptr sehingga anggota statis dapat menjadi virtual.

Itu tidak mungkin, tapi itu hanya karena kelalaian. Itu bukan sesuatu yang "tidak masuk akal" karena banyak orang tampaknya mengklaim. Untuk lebih jelasnya, saya berbicara tentang sesuatu seperti ini:

struct Base {
  static virtual void sayMyName() {
    cout << "Base\n";
  }
};

struct Derived : public Base {
  static void sayMyName() override {
    cout << "Derived\n";
  }
};

void foo(Base *b) {
  b->sayMyName();
  Derived::sayMyName(); // Also would work.
}

Ini adalah 100% sesuatu yang dapat diimplementasikan (hanya saja belum), dan saya berpendapat sesuatu yang berguna.

Pertimbangkan cara kerja fungsi virtual normal. Hapus statics dan tambahkan beberapa hal lain dan kami punya:

struct Base {
  virtual void sayMyName() {
    cout << "Base\n";
  }
  virtual void foo() {
  }
  int somedata;
};

struct Derived : public Base {
  void sayMyName() override {
    cout << "Derived\n";
  }
};

void foo(Base *b) {
  b->sayMyName();
}

Ini berfungsi dengan baik dan pada dasarnya yang terjadi adalah kompiler membuat dua tabel, yang disebut VTables, dan memberikan indeks ke fungsi virtual seperti ini

enum Base_Virtual_Functions {
  sayMyName = 0;
  foo = 1;
};

using VTable = void*[];

const VTable Base_VTable = {
  &Base::sayMyName,
  &Base::foo
};

const VTable Derived_VTable = {
  &Derived::sayMyName,
  &Base::foo
};

Selanjutnya setiap kelas dengan fungsi virtual ditambah dengan bidang lain yang menunjuk ke VTable-nya, sehingga kompiler pada dasarnya mengubahnya menjadi seperti ini:

struct Base {
  VTable* vtable;
  virtual void sayMyName() {
    cout << "Base\n";
  }
  virtual void foo() {
  }
  int somedata;
};

struct Derived : public Base {
  VTable* vtable;
  void sayMyName() override {
    cout << "Derived\n";
  }
};

Lalu apa yang sebenarnya terjadi ketika Anda menelepon b->sayMyName()? Pada dasarnya ini:

b->vtable[Base_Virtual_Functions::sayMyName](b);

(Parameter pertama menjadi this.)

Oke, jadi bagaimana cara kerjanya dengan fungsi virtual statis? Nah apa perbedaan antara fungsi anggota statis dan non-statis? Satu-satunya perbedaan adalah bahwa yang terakhir mendapatkan thispointer.

Kita dapat melakukan hal yang persis sama dengan fungsi virtual statis - cukup hapus thispointer.

b->vtable[Base_Virtual_Functions::sayMyName]();

Ini kemudian dapat mendukung kedua sintaks:

b->sayMyName(); // Prints "Base" or "Derived"...
Base::sayMyName(); // Always prints "Base".

Jadi abaikan semua penentang. Ini tidak masuk akal. Mengapa itu tidak didukung? Saya pikir itu karena manfaatnya sangat kecil dan bahkan bisa sedikit membingungkan.

Satu-satunya keunggulan teknis atas fungsi virtual normal adalah Anda tidak perlu beralih thiske fungsi tersebut, tetapi saya tidak berpikir itu akan membuat perbedaan yang terukur untuk kinerja.

Itu berarti Anda tidak memiliki fungsi statis dan non-statis yang terpisah untuk kasus ketika Anda memiliki instance, dan ketika Anda tidak memiliki instance, tetapi juga mungkin membingungkan bahwa itu hanya benar-benar "virtual" ketika Anda menggunakan panggilan instan.

Tidak, itu tidak mungkin, karena anggota statis terikat pada waktu kompilasi, sementara anggota virtual terikat pada saat runtime.

Pertama, balasannya benar bahwa yang diminta OP adalah kontradiksi dalam hal: metode virtual bergantung pada jenis run-time dari sebuah instance; fungsi statis secara khusus tidak bergantung pada instance - hanya pada tipe. Yang mengatakan, masuk akal untuk memiliki fungsi statis mengembalikan sesuatu yang spesifik untuk suatu tipe. Sebagai contoh, saya memiliki keluarga kelas MouseTool untuk pola Negara dan saya mulai memiliki masing-masing memiliki fungsi statis mengembalikan pengubah keyboard yang menyertainya; Saya menggunakan fungsi-fungsi statis di fungsi pabrik yang membuat instance MouseTool yang benar. Fungsi itu memeriksa keadaan mouse terhadap MouseToolA :: keyboardModifier (), MouseToolB :: keyboardModifier (), dll. Dan kemudian instantiated yang sesuai. Tentu saja kemudian saya ingin memeriksa apakah keadaannya benar jadi saya ingin menulis sesuatu seperti "

Jadi, jika Anda mendapati diri Anda menginginkan ini, Anda mungkin ingin mengulang solusi Anda. Namun, saya mengerti keinginan untuk memiliki metode statis dan kemudian menyebutnya secara dinamis berdasarkan pada jenis contoh yang dinamis. Saya pikir Pola Pengunjung dapat memberikan apa yang Anda inginkan. Ini memberi Anda apa yang Anda inginkan. Ini sedikit kode tambahan, tetapi bisa bermanfaat bagi pengunjung lain.

Lihat: http://en.wikipedia.org/wiki/Visitor_pattern untuk latar belakang.

struct ObjectVisitor;

struct Object
{
     struct TypeInformation;

     static TypeInformation GetTypeInformation();
     virtual void accept(ObjectVisitor& v);
};

struct SomeObject : public Object
{
     static TypeInformation GetTypeInformation();
     virtual void accept(ObjectVisitor& v) const;
};

struct AnotherObject : public Object
{
     static TypeInformation GetTypeInformation();
     virtual void accept(ObjectVisitor& v) const;
};

Kemudian untuk setiap Objek konkret:

void SomeObject::accept(ObjectVisitor& v) const {
    v.visit(*this); // The compiler statically picks the visit method based on *this being a const SomeObject&.
}
void AnotherObject::accept(ObjectVisitor& v) const {
    v.visit(*this); // Here *this is a const AnotherObject& at compile time.
}

dan kemudian tentukan pengunjung dasar:

struct ObjectVisitor {
    virtual ~ObjectVisitor() {}
    virtual void visit(const SomeObject& o) {} // Or = 0, depending what you feel like.
    virtual void visit(const AnotherObject& o) {} // Or = 0, depending what you feel like.
    // More virtual void visit() methods for each Object class.
};

Kemudian pengunjung konkret yang memilih fungsi statis yang sesuai:

struct ObjectVisitorGetTypeInfo {
    Object::TypeInformation result;
    virtual void visit(const SomeObject& o) {
        result = SomeObject::GetTypeInformation();
    }
    virtual void visit(const AnotherObject& o) {
        result = AnotherObject::GetTypeInformation();
    }
    // Again, an implementation for each concrete Object.
};

akhirnya, gunakan:

void printInfo(Object& o) {
    ObjectVisitorGetTypeInfo getTypeInfo;
    Object::TypeInformation info = o.accept(getTypeInfo).result;
    std::cout << info << std::endl;
}

Catatan:

• Constness pergi sebagai latihan.
• Anda mengembalikan referensi dari statis. Kecuali Anda memiliki singleton, itu dipertanyakan.

Jika Anda ingin menghindari kesalahan salin-tempel di mana salah satu metode kunjungan Anda memanggil fungsi statis yang salah, Anda bisa menggunakan fungsi pembantu templated (yang tidak bisa sendiri virtual) t pengunjung Anda dengan templat seperti ini:

struct ObjectVisitorGetTypeInfo {
    Object::TypeInformation result;
    virtual void visit(const SomeObject& o) { doVisit(o); }
    virtual void visit(const AnotherObject& o) { doVisit(o); }
    // Again, an implementation for each concrete Object.

  private:
    template <typename T>
    void doVisit(const T& o) {
        result = T::GetTypeInformation();
    }
};

Dengan c ++ Anda dapat menggunakan pewarisan statis dengan metode crt. Sebagai contoh, ini digunakan secara luas pada templat jendela atl & wtl.

Lihat https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern

Sederhananya, Anda memiliki kelas yang dibuat sendiri seperti kelas myclass: public myancestor. Dari titik ini kelas myancestor sekarang dapat memanggil fungsi T :: YourImpl statis Anda.

Mungkin Anda bisa mencoba solusi saya di bawah ini:

class Base {
public:
    Base(void);
    virtual ~Base(void);

public:
    virtual void MyVirtualFun(void) = 0;
    static void  MyStaticFun(void) { assert( mSelf != NULL); mSelf->MyVirtualFun(); }
private:
    static Base* mSelf;
};

Base::mSelf = NULL;

Base::Base(void) {
    mSelf = this;
}

Base::~Base(void) {
    // please never delete mSelf or reset the Value of mSelf in any deconstructors
}

class DerivedClass : public Base {
public:
    DerivedClass(void) : Base() {}
    ~DerivedClass(void){}

public:
    virtual void MyVirtualFun(void) { cout<<"Hello, it is DerivedClass!"<<endl; }
};

int main() {
    DerivedClass testCls;
    testCls.MyStaticFun(); //correct way to invoke this kind of static fun
    DerivedClass::MyStaticFun(); //wrong way
    return 0;
}

Seperti yang dikatakan orang lain, ada 2 informasi penting:

1. tidak ada thispointer saat membuat panggilan fungsi statis dan
2. yang thispointer menunjuk ke struktur di mana tabel virtual, atau dunk, digunakan untuk mencari metode yang runtime untuk memanggil.

Fungsi statis ditentukan pada waktu kompilasi.

Saya menunjukkan contoh kode ini di C + + anggota statis di kelas ; itu menunjukkan bahwa Anda dapat memanggil metode statis yang diberi pointer nol:

struct Foo
{
    static int boo() { return 2; }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Foo* pFoo = NULL;
    int b = pFoo->boo(); // b will now have the value 2
    return 0;
}