Tipp: lambda vs. FunctionObject

  • C++

    Tipp: lambda vs. FunctionObject

    Hallo Community

    Hier mal ganz einfach die Gegenüberstellung von lambda und FunctionObject für das C++.
    Wie es genau in der CLI-Version aussieht weiss ich leider nicht.
    Ich hoffe es hilft.

    Compiler: MSVC 2010

    Freundliche Grüsse

    exc-jdbi



    C-Quellcode

    1. #include "stdafx.h"
    2. #include <iostream>
    3. #include <functional>
    4. #include <windows.h>
    6. /* -------------------------------------------------------------------------------------------------- */
    7. //Es darf von FunctionObject gesprochen werden, wenn eine Funktion als Object (eigenständige Variable)
    8. //z.B. an eine Funktion übergeben werden kann.
    9. /* -------------------------------------------------------------------------------------------------- */
    11. /*
    12. // lambda-Basis
    13. auto func = [] () { cout << "A basic lambda" ; } ;
    15. // lambda-Funktion mit 'pass per value' in der Argumentenliste
    16. auto func = [](int n) { cout << n << " "; }
    18. // lambda-Funktion mit 'pass per ref' in der Argumentenliste
    19. auto func = [](int& n) { cout << n << " "; }
    21. // lambda-Funktion mit 'Capture List' wobei 'x,y' 'pass per Copy'
    22. int x = 4, y = 6;
    23. auto func = [x, y](int n) { return x < n && n < y; }
    25. // lambda-Funktion mit expliziten Rückgabe eines int-Wertes
    26. auto func = [] () -> int { return 42; }
    27. */
    29. typedef int (F_PTR)(); //Delegate
    30. F_PTR *ff_Func; //Functionsobject-Pointer
    32. int ff(){
    33. int i=50;
    34. std::cout<<"Rueckgabewert FunctionObject\t= "<<i<<std::endl;
    35. return i;
    36. }
    37. int sum0(int const &i,int const &y){
    38. return i+y;
    39. }
    40. int sum(int const &i,F_PTR f){
    41. return i+f();
    42. }
    43. int sum(int const &i,std::function<int()> const &f){
    44. return i+f();
    45. }
    47. int _tmain(int argc, _TCHAR* argv[]){
    49. //1. Alle folgende Funktionen haben einen Rückgabewert
    50. //****************************************************
    52. int res1=sum(20,&ff); //Als Funktionsobject mit 'std::function' >> C++-Style
    55. ff_Func=(F_PTR*)ff; //Die klassische C-Style-Funktion als
    56. int res2=sum(20,ff_Func); //FunctionObject (Pointerausführung)
    59. int res3=sum(20,(F_PTR*)ff); //Abkürzte C-Style-Version von res2 (Pointerausführung)
    61. //Die lambda-Funktion wird gekapselt und als FunktionsObject an die Funktion
    62. //sum(...) übergeben.
    63. int res4=sum(20,[]()-> int { // Als lambda-Funtion mit Rückgabe
    64. int i=50; // 'std::function<int()> const &f' wird aber trotzdem benötigt
    65. std::cout<<"Rueckgabewert Lambda\t\t= "<<i<<std::endl;
    66. return i;
    67. });
    69. auto res4a=[]()-> int { // lambda-Funtion mit Rückgabe als FunctionObject 'auto res4a'
    70. int i=50; // 'std::function<int()> const &f' wird benötigt
    71. std::cout<<"Rueckgabewert Lambda\t\t= "<<i<<std::endl;
    72. return i;
    73. };
    75. int res4b=sum(20,res4a); //ohne '()' dafür als FunctionObject übergeben
    80. //2. Funktionskörper in der Argumentenliste (Kein FunctionObject dafür lambda pur)
    81. //********************************************************************************
    83. int res5=sum0(20,ff()); //Die Funktion ff() wird in die Argumentenliste der Funktion sum0()
    84. //einbezogen (kein FunktionObject wird übergeben)
    86. auto res6=[]()-> int { // Als lambda-Funtion mit Rückgabe, die nachher als Funktionskörper
    87. int i=50; // in der Argumentenliste von sum0() deklariert ist. (siehe res7)
    88. std::cout<<"Rueckgabewert Lambda\t\t= "<<i<<std::endl;
    89. return i;
    90. };
    91. int res7=sum0(20,res6()); // Ganze lambda-Funktion als Variable res6() übergeben
    92. // Gleichzeitig kann res6() aber auch als FunctionObject dienen da 'auto'
    93. // >>> 'sum(20,res6);' Funktioniert auch (siehe res4b)
    95. int res8=sum0(20,[]() -> int { // Gleich wie res6 + res7, jedoch in die Argumentenliste eingebaut.
    96. int i=50;
    97. std::cout<<"Rueckgabewert Lambda\t\t= "<<i<<std::endl;
    98. return i;
    99. }());//Man beachte hier '}()' was einem Funktionsaufruf entspricht wie z.B. res6()
    101. getchar();
    102. return 0;
    103. }


    *Aus den Tipps&Tricks verschoben, da kein C++/CLI*

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Marcus Gräfe“ ()

Facebook