Apa yang dimaksud dengan delegasi C ++?

Apa ide umum delegasi di C ++? Untuk apa mereka, bagaimana mereka digunakan dan untuk apa mereka digunakan?

Pertama-tama saya ingin mempelajarinya dengan cara 'kotak hitam', tetapi sedikit informasi tentang nyali hal-hal ini juga bagus.

Ini bukan C ++ paling murni atau terbersih, tapi saya perhatikan bahwa basis kode tempat saya bekerja memiliki mereka dalam kelimpahan. Saya berharap untuk cukup memahami mereka, jadi saya hanya bisa menggunakannya dan tidak harus menyelidiki keasyikan templat bersarang yang mengerikan.

Dua artikel The Code Project ini menjelaskan apa yang saya maksud tetapi tidak terlalu ringkas:

• Pointer Fungsi Anggota dan Delegasi C ++ yang Tercepat Mungkin

• Delegasi C ++ yang Tidak Mungkin

Anda memiliki banyak pilihan untuk mencapai delegasi di C ++. Inilah beberapa yang muncul di pikiran saya.

Opsi 1: functors:

Objek fungsi dapat dibuat dengan mengimplementasikan operator()

struct Functor
{
     // Normal class/struct members

     int operator()(double d) // Arbitrary return types and parameter list
     {
          return (int) d + 1;
     }
};

// Use:
Functor f;
int i = f(3.14);

Opsi 2: ekspresi lambda (khusus C ++ 11 )

// Syntax is roughly: [capture](parameter list) -> return type {block}
// Some shortcuts exist
auto func = [](int i) -> double { return 2*i/1.15; };
double d = func(1);

Opsi 3: pointer fungsi

int f(double d) { ... }
typedef int (*MyFuncT) (double d);
MyFuncT fp = &f;
int a = fp(3.14);

Opsi 4: penunjuk ke fungsi anggota (solusi tercepat)

Lihat Fast C ++ Delegate (pada Proyek Kode ).

struct DelegateList
{
     int f1(double d) { }
     int f2(double d) { }
};

typedef int (DelegateList::* DelegateType)(double d);

DelegateType d = &DelegateList::f1;
DelegateList list;
int a = (list.*d)(3.14);

Opsi 5: std :: function

(atau boost::functionjika perpustakaan standar Anda tidak mendukungnya). Ini lebih lambat, tetapi yang paling fleksibel.

#include <functional>
std::function<int(double)> f = [can be set to about anything in this answer]
// Usually more useful as a parameter to another functions

Opsi 6: mengikat (menggunakan std :: bind )

Memungkinkan pengaturan beberapa parameter terlebih dahulu, mudah untuk memanggil fungsi anggota misalnya.

struct MyClass
{
    int DoStuff(double d); // actually a DoStuff(MyClass* this, double d)
};

std::function<int(double d)> f = std::bind(&MyClass::DoStuff, this, std::placeholders::_1);
// auto f = std::bind(...); in C++11

Opsi 7: template

Terima apa saja asalkan cocok dengan daftar argumen.

template <class FunctionT>
int DoSomething(FunctionT func)
{
    return func(3.14);
}

Delegasi adalah kelas yang membungkus pointer atau referensi ke instance objek, metode anggota kelas objek yang akan dipanggil pada instance objek itu, dan menyediakan metode untuk memicu panggilan itu.

Ini sebuah contoh:

template <class T>
class CCallback
{
public:
    typedef void (T::*fn)( int anArg );

    CCallback(T& trg, fn op)
        : m_rTarget(trg)
        , m_Operation(op)
    {
    }

    void Execute( int in )
    {
        (m_rTarget.*m_Operation)( in );
    }

private:

    CCallback();
    CCallback( const CCallback& );

    T& m_rTarget;
    fn m_Operation;

};

class A
{
public:
    virtual void Fn( int i )
    {
    }
};


int main( int /*argc*/, char * /*argv*/ )
{
    A a;
    CCallback<A> cbk( a, &A::Fn );
    cbk.Execute( 3 );
}

Kebutuhan akan implementasi delegasi C ++ adalah penghinaan jangka panjang bagi komunitas C ++. Setiap programmer C ++ akan senang memilikinya, jadi mereka akhirnya menggunakannya terlepas dari fakta bahwa:

1. std::function() menggunakan operasi tumpukan (dan berada di luar jangkauan untuk pemrograman tertanam yang serius).

2. Semua implementasi lain membuat konsesi terhadap portabilitas atau kesesuaian standar ke tingkat yang lebih besar atau lebih kecil (harap verifikasi dengan memeriksa berbagai implementasi delegasi di sini dan pada proyek codep). Saya belum melihat implementasi yang tidak menggunakan reinterpret_casts liar, kelas bertingkat "prototipe" yang mudah-mudahan menghasilkan pointer fungsi dengan ukuran yang sama seperti yang dilewati oleh pengguna, trik kompiler seperti pertama maju menyatakan, kemudian ketik kemudian mendeklarasikan lagi, kali ini mewarisi dari kelas lain atau teknik teduh serupa. Meskipun ini adalah pencapaian besar bagi para pelaksana yang membangunnya, itu masih merupakan kesaksian yang menyedihkan tentang bagaimana C ++ berkembang.

3. Jarang sekali ditunjukkan, bahwa sekarang lebih dari 3 revisi standar C ++, delegasi tidak ditangani dengan baik. (Atau kurangnya fitur bahasa yang memungkinkan implementasi delegasi langsung.)

4. Dengan cara fungsi C ++ 11 lambda didefinisikan oleh standar (setiap lambda memiliki jenis anonim, berbeda), situasinya hanya membaik dalam beberapa kasus penggunaan. Tetapi untuk kasus penggunaan menggunakan delegasi di (DLL) perpustakaan API, lambdas sendiri masih tidak dapat digunakan. Teknik umum di sini, adalah untuk pertama-tama mengemas lambda menjadi fungsi std :: dan kemudian menyebarkannya ke seluruh API.

Sederhananya, delegasi menyediakan fungsionalitas untuk bagaimana fungsi pointer HARUS bekerja. Ada banyak batasan fungsi pointer di C ++. Seorang delegasi menggunakan beberapa kejelekan templat di belakang layar untuk membuat kelas-jenis-fungsi-pointer-templat yang berfungsi sesuai keinginan Anda.

yaitu - Anda dapat mengatur mereka untuk menunjuk pada fungsi yang diberikan dan Anda dapat menyebarkannya dan memanggil mereka kapanpun dan dimanapun Anda suka.

Ada beberapa contoh yang sangat bagus di sini:

• http://www.codeproject.com/Articles/7150/Member-Function-Pointers-and-the-Fastest-Mungkin
• http://www.codeproject.com/Articles/11015/The-Impossibly-Fast-C-Delegates
• http://www.codeproject.com/Articles/13287/Fast-C-Delegate

Opsi untuk delegasi dalam C ++ yang tidak disebutkan di sini adalah melakukannya dengan gaya C menggunakan ptr fungsi dan argumen konteks. Ini mungkin merupakan pola yang sama yang banyak orang menanyakan pertanyaan ini coba hindari. Namun, polanya portabel, efisien, dan dapat digunakan dalam kode tertanam dan kernel.

class SomeClass
{
    in someMember;
    int SomeFunc( int);

    static void EventFunc( void* this__, int a, int b, int c)
    {
        SomeClass* this_ = static_cast< SomeClass*>( this__);

        this_->SomeFunc( a );
        this_->someMember = b + c;
    }
};

void ScheduleEvent( void (*delegateFunc)( void*, int, int, int), void* delegateContext);

    ...
    SomeClass* someObject = new SomeObject();
    ...
    ScheduleEvent( SomeClass::EventFunc, someObject);
    ...

Windows Runtime setara dengan objek fungsi dalam standar C ++. Satu dapat menggunakan seluruh fungsi sebagai parameter (sebenarnya itu adalah pointer fungsi). Itu sebagian besar digunakan bersama dengan acara. Delegasi tersebut mewakili kontrak yang dipenuhi oleh para penangan acara. Ini memfasilitasi bagaimana fungsi pointer dapat bekerja.