Useful for passing functions as arguments to algorithms.<\/li>\n<\/ul>\nConsider this pre-C++11 code:<\/p>\n
cpp
\n#include
\n#include
\n#include <\/p>\n
bool isEven(int n) {
\n return n % 2 == 0;
\n}<\/p>\n
int main() {
\n std::vector numbers = {1, 2, 3, 4, 5, 6};
\n std::vector evenNumbers;<\/p>\n
std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(evenNumbers), isEven);<\/p>\n
for (int num : evenNumbers) {
\n std::cout << num << " ";
\n }
\n std::cout << std::endl;
\n return 0;
\n}<\/p>\n
Now, let’s see how lambdas can simplify this:<\/p>\n
cpp
\n#include
\n#include
\n#include <\/p>\n
int main() {
\n std::vector numbers = {1, 2, 3, 4, 5, 6};
\n std::vector evenNumbers;<\/p>\n
std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(evenNumbers),
\n [](int n){ return n % 2 == 0; }); \/\/ Lambda expression<\/p>\n
for (int num : evenNumbers) {
\n std::cout << num << " ";
\n }
\n std::cout << std::endl;
\n return 0;
\n}<\/p>\n
Notice how the isEven<\/code> function is replaced by a lambda expression directly within the std::copy_if<\/code> function call. This eliminates the need for a separate function declaration and makes the code more compact and easier to understand. The lambda expression `[](int n){ return n % 2 == 0; }` defines an anonymous function that takes an integer `n` as input and returns `true` if `n` is even, and `false` otherwise.<\/p>\nLambdas also support capturing variables from the surrounding scope. For instance:<\/p>\n
cpp
\n#include
\n#include
\n#include <\/p>\n
int main() {
\n int threshold = 3;
\n std::vector numbers = {1, 2, 3, 4, 5, 6};
\n std::vector filteredNumbers;<\/p>\n
std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(filteredNumbers),
\n [threshold](int n){ return n > threshold; }); \/\/ Capture ‘threshold’<\/p>\n
for (int num : filteredNumbers) {
\n std::cout << num << " ";
\n }
\n std::cout << std::endl;
\n return 0;
\n}<\/p>\n
Here, `[threshold]` captures the threshold<\/code> variable by value, allowing the lambda to use it in its logic. You can also capture by reference using `[&threshold]`. This can be very useful for modifying variables in the outer scope, but it requires caution to avoid dangling references.<\/p>\nAuto: Simplifying Type Deduction \ud83d\udca1<\/h2>\n
The auto<\/code> keyword allows the compiler to automatically deduce the type of a variable based on its initializer. This reduces code verbosity and improves readability, especially when dealing with complex types or template expressions. Using auto<\/code> can also help prevent errors caused by manually specifying the wrong type.<\/p>\n\n- Automatic type deduction simplifies code.<\/li>\n
- Reduces code verbosity and improves readability.<\/li>\n
- Prevents errors caused by incorrect type specification.<\/li>\n
- Useful for complex types and template expressions.<\/li>\n
- Promotes code maintainability and flexibility.<\/li>\n
- Enhances code clarity by focusing on logic rather than type declarations.<\/li>\n<\/ul>\n
Before C++11, you might have to write something like this:<\/p>\n
cpp
\n#include
\n#include <\/p>\n
int main() {
\n std::vector numbers = {1, 2, 3, 4, 5, 6};
\n std::vector::iterator it = numbers.begin(); \/\/ Verbose iterator declaration<\/p>\n
for (; it != numbers.end(); ++it) {
\n std::cout << *it << " ";
\n }
\n std::cout << std::endl;
\n return 0;
\n}<\/p>\n
With auto<\/code>, the code becomes much cleaner:<\/p>\ncpp
\n#include
\n#include <\/p>\n
int main() {
\n std::vector numbers = {1, 2, 3, 4, 5, 6};
\n auto it = numbers.begin(); \/\/ Type deduced as std::vector::iterator<\/p>\n
for (; it != numbers.end(); ++it) {
\n std::cout << *it << " ";
\n }
\n std::cout << std::endl;
\n return 0;
\n}<\/p>\n
The compiler infers that it<\/code> is of type std::vector<int>::iterator<\/code>. This makes the code more readable and less prone to errors, especially when dealing with complicated template types. Moreover, it’s incredibly helpful when dealing with return types of template functions, where knowing the exact return type can be tricky.<\/p>\nHere’s another example:<\/p>\n
cpp
\n#include
\n#include <\/p>\n