C++11 Lambda

Transcript

1. C++11 Lambda Matthew 2013-11-14
3. Outline • Lambda syntax • Lambda in STL algorithms • Lambda as callback • Lambda in concurrency • Lambda as scope guard
4. Visual C++ Support For C++11 Features (Modern C++) http://msdn.microsoft.com/en- us/library/vstudio/hh567368.aspx VS2010 or later support Lambda.
5. Greetings void greetings() { cout << "Hello!"; } int main() { greetings(); } -------------Output------------ Hello!
6. First Lambda int main() { auto greetings = [] { cout << "Hello Lambda!"; }; greetings(); } -------------Output------------ Hello Lambda! lambda syntax starting with [ ]
7. // Create a lambda and call it immediately. int main() { [] { cout << "Hello Lambda!"; } (); } -------------Output------------ Hello Lambda!
8. int main() { auto func = [] ( string strName ) { cout << "Hello " << strName << endl; }; func( "Taco" ); } -------------Output------------ Hello Taco! Pass parameter to a lambda
9. int main() { auto func = [] ( float f1, float f2 ) { return f1 + f2; }; cout << func( 2.5, 7.5 ); } -------------Output------------ 10 Lambda can return something.
10. int main() { auto func = [] ( float f1, float f2 ) -> float { return f1 + f2; }; cout << func( 2.5, 7.5 ); } -------------Output------------ 10 Specify return type.
11. What's the Difference from function pointer?
12. Captures (access outer scope)
13. int main() { string strName = "Matthew"; auto func = [strName] { cout << "Hello " << strName; }; func(); } -------------Output------------ Hello Matthew Capture variable "strName".
14. int main() { string strName = "Matthew"; auto func = [=] { cout << "Hello " << strName; }; func(); } -------------Output------------ Hello Matthew Auto capture all variables by copy.
15. int main() { string strName = "Matthew"; auto func = [=] { strName = "Terence"; // Ooops, compiler error. cout << "Hello " << strName; }; func(); } -------------Output------------
16. int main() { string strName = "Matthew"; auto func = [&] { strName = "Terence"; // OK! cout << "Hello " << strName; }; func(); } -------------Output------------ Hello Matthew Auto capture all variables by reference.
17. [] Capture nothing [&] Capture any referenced variable by reference [=] Capture any referenced variable by making a copy [=, &foo] Capture any referenced variable by making a copy, but capture variable foo by reference [bar] Capture bar by making a copy; don't copy anything else [this] Capture the this pointer of the enclosing class [x, &y, z ] Capture x, z by making a copy; capture y by reference; don't copy anything else
18. Why lambda rocks? ( std::for_each as example)
19. void plus10( int& i ) { i = i + 2; } int main() { vector<int> v { 1, 2, 3, 4, 5 }; for_each( v.begin(), v.end(), plus10 ); // print v } -------------Output------------ 11 12 13 14 15 <<< The Old Way
20. void plusN( int& i ) { i = i + n; } int main() { vector<int> v { 1, 2, 3, 4, 5 }; cin >> n; for_each( v.begin(), v.end(), plusN ); // print v } -------------Output------------ <= How to get n ??
21. int main() { vector<int> v { 1, 2, 3, 4, 5 }; cin >> n; auto plusN = [n] ( int &i ) { i = i + n; }; for_each( v.begin(), v.end(), plusN ); // print v } -------------Output------------ n is 4 5 6 7 8 9 std::for_each() in lambda
22. int main() { vector<int> v { 1, 2, 3, 4, 5 }; cin >> n; for_each( v.begin(), v.end(), [n] ( int &i ) { i = i + n; } ); // print v } -------------Output------------ n is 4 5 6 7 8 9 <<< inline Lambda
23. int main() { vector<int> v { 1, 2, 3, 4, 5 }; cin >> n; for_each( v.begin(), v.end(), [n] ( int &i ) { i = i + n; } ); // print v } -------------Output------------ <<< inline Lambda
24. std::find_if vector<string> v { "Apple", "Banana", "Cat", "Doom" }; char firstLetter = 'C'; auto pos = find_if( v.begin(), v.end(), [=](string str) { return str[0] == firstLetter; }); cout << *pos; -------------Output------------ Cat
25. std::transform vector<int> v { 1, 2, 3, 4, 5 }; vector<int> v2; transform( v.begin(), v.end(), // source v2.begin(), // destination [](int i) { return i * i * i; // to the power of 3 }); for_each( v2.begin(), v2.end, [] (int &i) {cout << i << " "} ); -------------Output------------
26. Lambda syntax [ capture ] ( params ) mutable exception attribute -> ret { body } [ capture ] ( params ) -> ret { body } [ capture ] ( params ) { body } [ capture ] { body }
27. Type of lambdas
28. Type of a Lambda • Anonymous function object • Unique for each lambda. • Using std::function to wrap lambda, ex: std::function< bool(int) > func = [] ( int i ) -> bool { return i % 2; }; func( 4 ); #include<functional>
29. Lambda as callback
30. 情境 CVideoExporter 輸出影片 CVideoExportDialog 顯示輸出進度和訊息 的對話框
31. class CVideoExporter { public: std::function< void() > onWorkCompleted; std::function< void() > onWorkCanceled; std::function< void(RL::Result) > onWorkFailed; std::function< void(float) > onProgressChanged; Result start(); Result cancel(); ... };
32. CVideoExporter* e = new CVideoExporter; CVideoExportDialog* d = new CVideoExportDialog; e.onWorkCompleted = [=] { d.ShowMesseage( "Video Exporting Success." ); }; e.onWorkCanceled = [=] { d.closeDialog(); }; e.onWorkFailed = [=] ( RL::Result result ) { d.ShowMessage( errorMessage( result ) ); }; e.onProgressChanged = [=] ( float fProgress ) { d.setProgress( fProgress ); }; e.start();
33. Lambda in Qt5 signal/slot void Doc::saveDocument() { QFileDialog* dlg = new QFileDialog(); dlg->open(); QObject::connect(dlg, &QDialog::finished, [dlg, this](int result) { if (result) { QFile file(dlg->selectedFiles().first()); // ... } dlg->deleteLater(); }); }
34. Lambda in Concurrency
35. std::future long long n = 313221123313213213; std::future<bool> ft = std::async( [=] { return IsPrime( n ); } ); ...perform foreground task. bool bIsPrime = ft.get(); // get result later. #include<future>
36. template<class InputIterator> int parallel_sum( InputIterator beg, InputIterator end ) { typename InputIterator::difference_type len = end - beg; if ( len < 1000 ) return std::accumulate( beg, end, 0 ); InputIterator mid = beg + len / 2; auto handle = std::async( std::launch::async, [&] { parallel_sum( mid, end ); } ); int sum = parallel_sum( beg, mid ); return sum + handle.get(); } int main() { std::vector<int> v(10000, 1); std::cout << "The sum is " << parallel_sum( v.begin(), v.end() ) << '\n'; }
37. http://coliru.stacked-crooked.com/a/9115158e3f045572
38. Lambda as Scope guard
39. Scope Guard void foo() { HANDLE h = CreateFile(...); IXXXObject* = CreateXXX(..); ON_SCOPE_EXIT ( CloseHandle( h ); SAFE_RELEASE( IXXXObject ); ) ... // use the file }
40. ON_SCOPE_EXIT #define ON_SCOPE_EXIT(callback) \ ScopeGuard onExit( [&] { callback } ); void foo() { HANDLE h = CreateFile(...); ScopeGuard onExit ( [&] { CloseHandle(h); } ); ... // use the file }
41. ScopeGuard class ScopeGuard { public: explicit ScopeGuard( std::function<void()> onExitScope ) : m_onExitScope( onExitScope ) { } ~ScopeGuard() { m_onExitScope(); } private: std::function<void()> m_onExitScope; };