[c++0x] Auto/template en lambda parameters

[Olaf van der Spek]

Ik heb deze lambda maar zou graag auto of template voor de parametertypes gebruiken. Is dit mogelijk?
Letterlijk auto in plaats van countries_t::const_pointer werkt in ieder geval niet.

C++:

        std::sort(countries1.begin(), countries1.end(), [](countries_t::const_pointer a, countries_t::const_pointer b) 
        { 
            return a->second.first + a->second.second > b->second.first + b->second.second || a->second.first + a->second.second == b->second.first + b->second.second && a->first < b->first; 
        });

[.oisyn]

Nope, kan niet. Zou hij ook nooit kunnen matchen, de 3e parameter van sort is ook maar gewoon een T

[Olaf van der Spek]

Dat is jammer. Een lambda meegeven aan een lambda kan dan dus ook niet.

de 3e parameter van sort is ook maar gewoon een T

Dat is toch geen probleem? Als je een functie template in plaats van een lambda gebruikt kan het wel.

[ Voor 53% gewijzigd door Olaf van der Spek op 03-02-2011 19:19 ]

[PrisonerOfPain]

Olaf van der Spek schreef op donderdag 03 februari 2011 @ 19:18:
Dat is jammer. Een lambda meegeven aan een lambda kan dan dus ook niet.

Daar heb je std::function<>() voor.

[.oisyn]

Olaf van der Spek schreef op donderdag 03 februari 2011 @ 19:18:
Dat is toch geen probleem? Als je een functie template in plaats van een lambda gebruikt kan het wel.

Nee, dat werkt andersom. Als jij een Foo<T>(T) hebt, en jij roept 'm aan met int, dan kan ie zien dat T een int moet zijn. Als jij Foo aanroept met een lambda die 1 parameter verwacht, hoe moet ie dan zien wat het type van die ene parameter is?

Wat ik wel erg jammer vind aan lambda's is dat ze verder totaal geen signature informatie met zich meedragen. Je kunt in een template dus niet de signature ontdekken, en je kan er al helemaal niet op overloaden (zoals dat in .Net bijvoorbeeld wel kan). En 't is niet dat zoiets onmogelijk is - ze hadden er voor kunnen kiezen dat elke lambda bijvoorbeeld derived van een std::lambda<T,SIG>, met T het daadwerkelijke derived type en SIG de signature. Op dat moment kun je wel gewoon overloaden:

C++:

template<class T> void Foo(std::lambda<T, void()> & p)
{
    p();
}

template<class T> void Foo(std::lambda<T, void(int)> & p)
{
    p(34);
}

[ Voor 41% gewijzigd door .oisyn op 03-02-2011 22:02 ]

[Olaf van der Spek]

.oisyn schreef op donderdag 03 februari 2011 @ 21:57:
Als jij Foo aanroept met een lambda die 1 parameter verwacht, hoe moet ie dan zien wat het type van die ene parameter is?

Lambda parsen zonder type info en het type afleiden op het moment dat de lambda wordt aangeroepen.

[.oisyn]

Ja, leuk bedacht, maar zo werkt C++ gewoon niet . Wat als je de lambda nooit aanroept, maar bijv. gewoon opslaat? En wat als je de lambda meerdere keren aanroept met verschillende soorten parameters die wel impliciet converteerbaar zijn naar elkaar? En wat als de implementatie van de template gewoon niet bekend is?

[ Voor 11% gewijzigd door .oisyn op 04-02-2011 01:38 ]

[Olaf van der Spek]

.oisyn schreef op vrijdag 04 februari 2011 @ 01:37:
Ja, leuk bedacht, maar zo werkt C++ gewoon niet . Wat als je de lambda nooit aanroept, maar bijv. gewoon opslaat? En wat als je de lambda meerdere keren aanroept met verschillende soorten parameters die wel impliciet converteerbaar zijn naar elkaar? En wat als de implementatie van de template gewoon niet bekend is?

Dan heb je toch dezelfde situatie als een template functie die je niet aanroept? Dan heb je dus een template lambda.

[.oisyn]

Nee, als je een template functie aan een andere template functie voert, dan moet die template functie (de parameter) geinstantieerd worden aan de hand van de signature van de callee. En ook als je 'm opslaat maar nooit aanroept moet ie geinstantieerd worden.

Overigens is een lambda een object, geen functie. Wat eventueel nog wel zou kunnen is dat de operator() van die lambda een template is. Dit werkt tenslotte ook:

C++:

struct countrysorter
{
    template<class T> operator()(T a, T b) const
    {
        return a->second.first + a->second.second > b->second.first + b->second.second || a->second.first + a->second.second == b->second.first + b->second.second && a->first < b->first;  
    }
}

void foo()
{
    std::sort(countries1.begin(), countries1.end(), countrysorter());
}

Wellicht dat ze deze syntax toe hadden moeten staan:

C++:

std::sort(countries1.begin(), countries1.end(), []<class T>(T a, T b)  
        {  
            return a->second.first + a->second.second > b->second.first + b->second.second || a->second.first + a->second.second == b->second.first + b->second.second && a->first < b->first;  
        });

[ Voor 73% gewijzigd door .oisyn op 04-02-2011 11:01 ]