Dotaz: c++0x, std::function

[Jardík]

Stala se mi taková věc. Něco jsem programoval a použil jsem tam callbacky ve stylu

std::function<void (EraseResult)> OnEraseDone;

std::thread eraseDisc(bool quick, OnEraseDone callback)
{
  std::thread th(std::bind(&Device::_eraseThread, this, callback));
  return std::move(th);
}

void _eraseThread(OnEraseDone callback)
{
  // blabla
}

Callbacky mi tak hezky fungovaly, ale jen do té doby, než jsem místo obyčejné funkce jako callback chtěl použít pointer na metodu:

// v metodě objektu typu Test
std::thread th = eraseDisc(true, OnEraseDone(&Test::eraseDone, this));

Kompilátor nahlásí slušnou 100 řádkovou chybu, ze které se zdá, že takový konstruktor std::function nemá a std::bind mi taky nepomůže. Otázkou tedy je, co použít místo std::function (GCC 4.4 ještě neumí lambda funkce, tak ty taky ne, boost knihovnu taky nee), nebo poradit, co dělám špatně.

---

---

Odpovědi

[Sinuhet]

Use the std::mem_fn, Jardiku!

[Jardík]

Takováto odpověď mi nestačí. mem_fn jenom obsáhne ten pointer na metodu, ale né objekt, na který se to má volat a je třeba ho poté uvést, což není to, co potřebuju.

[Jirka P]

To, co potřebuješ, je bind (nějak takhle):

eraseDisc(true, boost::bind(&Objekt::metoda, this));

Skoro jistě (nechce se mi to zjišťovat) je to v C++0x taky (asi se to bude jmenovat std::bind), najdi si to.

Nebo můžeš bejt frikulín, a jít do lambdy (bez záruky jak na syntax, tak na funkčnost v nějakým kompilátoru):

eraseDisc(true, []{ this->metoda(); } );

Na std::function je konvertovatelný buď func-pointer, nebo funktor.

[Jardík]

V dotazu jsem snad psal, že GCC lambdy zatím nemá (je sice SVN branch, který je má, ale extra kompilovat gcc se mi moc nechce).

[Sinuhet]

Tahleta dnesni mladez ...

std::bind(std::mem_fn(&Test::eraseDone), this)

[Jardík]

Tak na tohle mem_fn() nepotřebuju, to zvládne bind() i bez toho. Problém však je, že výsledek nemůžu přiřadit do std::function<void (EraseResult)>

[Sinuhet]

Jo aha, vy tam mate jeste jeden volnej parametr... s vama je teda prace!

#include <functional>
#include <string>
#include <iostream>


struct test
{
        void run(const std::string& message)
        {
                std::cout << message << "\n";
        }
};

int main(int argc, char** argv)
{
        using namespace std::placeholders;

        test t;
        std::function<void (const std::string&)> f = std::bind(&test::run, &t, _1);

        f("Hola hola");
}

(Mate recht, jde to i bez std::mem_fn, musim se podivat, proc mne to bez nej kdysi neslo...)

[Jirka P]

Jestli to má mít ještě parametry, tak:

std::bind(&Test::eraseDone, this, std::placeholders::_1)

[Jardík]

To je ono Děkuju.

[Ivan]

Koukam ze uz jsi to vyresil. Stejne si ale neodpustim jednu OT poznamku, kterou si jeste pamatuju jeste ze skoly. Nas prednasejici se jednou rozpovidal na tema jakej straslivej opruz byl implementovat member pointery v jeho kompilatoru. Kompilator musi pripravit kod, kterej za behu rozhodne jestli je metoda virtualni nebo ne, jestli nahodou neni zdedena od virtualniho predka a pod. Te to prej desna magie a v zavislosti na implementaci zabira member pointer 6-12B na 32bit platformach. Je to jedna z nejtezsich veci pro impementatory C++ kompilatoru. Ja jsem si z toho vzal ponauceni ze nikdy member pointer pouzivat nebudu, ze mi staci trida command s metorou run.

[Jirka P]

Upřímně řečeno, z takovéhle logiky se mi otvírá kudla v kapse. Když to převyprávím, tak prostě nějaký přednášející něco implementoval, nešlo mu to, tak to prohlásil za opruz, a učí to studenty nepoužívat.

K jednotlivým bodům:

Kompilator musi pripravit kod, kterej za behu rozhodne jestli je metoda virtualni nebo ne, jestli nahodou neni zdedena od virtualniho predka a pod.

Nikoliv, kompilátor nic takového dělat nemusí. Ani nemůže, protože za běhu v programu taková informace prostě není (ledaže by si ji tam ten implementátor speciálně kvůli tomuhle přidal, ale v takovém případě je pochybné mluvit o tom jako o opruzu - implementátor si za ten opruz může sám, a to i v případě, kdy chce dodržet nějaké ABI). Pokud jde o ukazatele na metodu, je situace celkem jednoduchá - asi nejjednodušší implementace je dvojice (pointer na funkci, offset pro this) s tím, že pro volání virtuální funkce ap. kompilátor vygeneruje kód

Ret synthesized_thunk(T* that, Args... args) {
  that->real_function(args);
}

a tuhle funkci použije do toho PMF.

zabira member pointer 6-12B na 32bit platformach

To není vůbec k divení, takových věcí je víc.

Je to jedna z nejtezsich veci pro impementatory C++ kompilatoru

Implementoval ten váš expert RTTI? Výjimky? Linker? To jsou všechno věci těžší, anebo pracnější, a zcela určitě jejich datové struktury zabírají víc, než pouhých 12 B.

Ja jsem si z toho vzal ponauceni ze nikdy member pointer pouzivat nebudu

Uniká mi logika tohohle kroku. I když to nebudete používat, implementovat se to bude pořád stejně (těžce nebo lehce, to je jedno).

ze mi staci trida command s metorou run.

... čímž se ochudíte o jakýkoli generický kód, který spolupracuje s funktory.

Disclaimer: Tento příspěvek rozhodně nemá vyvolat dojem, že PMF by se měly používat nějak masově. IMHO jsou PMF v C++ jedním z reliktů C (v tomto případě ukazatelů na funkce) a jejich použití přináší např. výkonnostní problémy, na druhou stranu není jednoduché a nepodporuje znovupoužitelnost kódu.

[dark]

A co toto, celkem jednoduché a fungovalo mi to zatím všude:)

Member Function Pointers and the Fastest Possible C++ Delegates

[Jardík]

O tom já přece vím, ale já chtěl c++0x řešení