C++11 03-Lambda 表达式

系列文章目录

点击直达——文章总目录

文章目录

C++11 03-Lambda 表达式

Overview

1.Lambda 表达式

C++11 引入了 Lambda 表达式，这是一种便捷的匿名函数声明方式，可以使得编写内联函数变得更加简单和直观。Lambda 表达式通常用于短暂的、不需要复用的小函数，尤其适合用于算法参数、事件处理器或任何需要临时函数的场景。

1.1.Lambda 表达式的语法

基本语法如下：

[](parameters) mutable -> return_type {
    // function body
}
  • 1
  • 2
  • 3

各部分说明：

  • []：捕获子句（Capture Clause）。定义了 Lambda 表达式从封闭作用域中捕获哪些变量。可以按值或按引用捕获变量。
  • parameters：参数列表。与普通函数参数列表类似，可以有默认参数，甚至可以没有参数。
  • mutable：如果 Lambda 表达式需要修改捕获的变量，需要声明为 mutable。
  • -> return_type：返回类型。可以省略，编译器将自动推导返回类型。
  • function body：函数体。

1.2.Lambda 表达式的特点

  1. 匿名性：Lambda 表达式是匿名的，即它们没有名字。
  2. 简洁性：Lambda 表达式提供了一种书写简洁的匿名函数的方式。
  3. 泛用性：可以用在任何需要函数对象的地方。

1.3.示例

1.3.1. 简单的 Lambda 表达式
#include 
#include 
#include 

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};

    // 使用 Lambda 表达式进行简单的操作
    std::for_each(v.begin(), v.end(), [](int n) {
        std::cout << n << " ";
    });
    std::cout << std::endl;

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
1.3.2. 捕获外部变量
#include 
#include 

int main() {
    int outside_var = 10;
    std::vector<int> v = {1, 2, 3, 4, 5};

    // 捕获外部变量
    auto lambda = [outside_var](int x) {
        return x + outside_var;
    };

    for (int n : v) {
        std::cout << lambda(n) << " ";
    }
    std::cout << std::endl;

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
1.3.3. 修改捕获的变量
#include 

int main() {
    int counter = 0;

    auto increment = [&counter]() {
        counter++;
    };

    increment();
    increment();
    std::cout << "Counter: " << counter << std::endl;

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
1.3.4. 使用默认参数和返回类型推导
#include 
#include 

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};

    // 使用默认参数和 auto 关键字
    auto square = [](auto n) -> auto {
        return n * n;
    };

    for (int n : v) {
        std::cout << square(n) << " ";
    }
    std::cout << std::endl;

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

1.4.注意事项

  • 捕获子句：Lambda 表达式可以捕获局部变量，可以按值（默认）或按引用捕获。
  • mutable 关键字：如果 Lambda 表达式需要修改捕获的变量，需要声明为 mutable。
  • 泛型 Lambda 表达式：C++14 引入了泛型 Lambda 表达式，可以使用 auto 关键字作为参数类型。

Lambda 表达式是现代 C++ 编程中一个非常强大的特性，使得代码更加简洁和灵活。

2.Lambda 表达式在 STL 算法中的应用有哪些？

Lambda 表达式在 STL 算法中的应用非常广泛，它们提供了一种便捷的方式来定义和使用匿名函数。以下是一些常见的应用场景：

  1. 搜索和过滤：
    使用 std::find_if 算法配合 Lambda 表达式可以方便地搜索满足特定条件的元素。

    auto it = std::find_if(vec.begin(), vec.end(), [](int x) { return x > 10; });
    • 1

  2. 计数：
    std::count_if 算法可以用来计数满足特定条件的元素数量。

    int count = std::count_if(vec.begin(), vec.end(), [](int x) { return x % 2 == 0; });
    • 1

  3. 排序：
    std::sort 算法可以使用 Lambda 表达式作为自定义的比较函数。

    std::sort(vec.begin(), vec.end(), [](int a, int b) { return a < b; });
    • 1

  4. 去重：
    结合 std::unique 和 std::sort，可以使用 Lambda 表达式进行去重操作。

    auto last = std::unique(vec.begin(), vec.end(), [](int a, int b) { return a == b; });
vec.erase(last, vec.end());
    • 1
    • 2

  5. 转换：
    std::transform 算法可以应用 Lambda 表达式对每个元素进行转换。

    std::transform(vec.begin(), vec.end(), vec.begin(), [](int x) { return x * x; });
    • 1

  6. 复制：
    std::copy_if 可以用来复制满足特定条件的元素到另一个容器中。

    std::copy_if(vec.begin(), vec.end(), std::back_inserter(result), [](int x) { return x > 5; });
    • 1

  7. 生成：
    std::generate 和 std::generate_n 可以用来生成一系列元素，Lambda 表达式在这里定义了生成规则。

    std::generate(vec.begin(), vec.end(), []() { static int x = 0; return ++x; });
    • 1

  8. 统计：
    可以编写一个 Lambda 表达式来统计容器中满足特定条件的元素数量。

    int sum = 0;
std::for_each(vec.begin(), vec.end(), [&sum](int x) { sum += x; });
    • 1
    • 2

  9. 条件替换：
    std::replace_if 可以用来条件性地替换元素。

    std::replace_if(vec.begin(), vec.end(), [](int x) { return x > 10; }, 0);
    • 1

  10. 查找和替换：
    结合 std::find_if 和 std::iter_swap，可以使用 Lambda 表达式查找并替换元素。

    auto it = std::find_if(vec.begin(), vec.end(), [](int x) { return x == 5; });
if (it != vec.end()) {
    std::iter_swap(it, vec.begin());
}
    • 1
    • 2
    • 3
    • 4

Lambda 表达式在 STL 算法中的应用大大提高了代码的简洁性和可读性。通过上述示例，你可以看到 Lambda 表达式如何与 STL 算法结合使用，实现各种复杂的操作。

3.Lambda 表达式在 STL 算法中如何提高代码的可读性和可维护性？

Lambda 表达式在 STL 算法中通过以下方式提高代码的可读性和可维护性：

  1. 内联代码：Lambda 表达式允许你将函数直接内联到调用点，这样可以减少函数定义和调用的跳转，使代码更加紧凑和直观。

  2. 明确的意图：Lambda 表达式可以明确地表达算法的意图，因为它们通常紧随算法调用，并且与算法操作直接相关。

  3. 减少模板代码：对于泛型编程，Lambda 表达式可以避免编写冗长的模板代码，简化了代码结构。

  4. 避免全局函数：不需要为简单的操作定义全局函数或重载操作符，减少了全局命名空间的污染。

  5. 捕获外部变量：Lambda 表达式可以捕获并使用外部变量，这减少了在算法调用中传递参数的需要，使得代码更加简洁。

  6. 类型自动推导：Lambda 表达式的参数类型和返回类型可以由编译器自动推导，减少了模板元编程的复杂性。

  7. 增强的表达力：Lambda 表达式提供了一种表达复杂操作的方式，使得代码更加直观易懂。

  8. 错误减少：由于算法和操作定义在同一个作用域内，减少了因函数调用错误或参数传递错误导致的问题。

  9. 代码组织：Lambda 表达式可以作为算法的参数直接传递，使得代码的逻辑结构更加清晰。

  10. 重用性：虽然 Lambda 表达式通常用于一次性操作，但它们也可以定义在循环或条件语句之外，以提高代码的重用性。

3.1.示例

假设我们有一个 std::vector 容器，我们想要找出所有大于某个值的元素，并将它们乘以2后存储在另一个容器中。

不使用 Lambda 表达式：

void processElements(const std::vector<int>& input, std::vector<int>& output, int threshold) {
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] > threshold) {
            output.push_back(input[i] * 2);
        }
    }
}

// 在主函数中调用
std::vector<int> vec = {1, 2, 3, 4, 5};
std::vector<int> result;
processElements(vec, result, 2);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

使用 Lambda 表达式：

std::vector<int> vec = {1, 2, 3, 4, 5};
std::vector<int> result;
std::copy_if(vec.begin(), vec.end(), std::back_inserter(result), [](int x) { return x > 2; });
std::transform(result.begin(), result.end(), result.begin(), [](int x) { return x * 2; });
  • 1
  • 2
  • 3
  • 4

或者结合为一个步骤：

std::vector<int> vec = {1, 2, 3, 4, 5};
std::vector<int> result;
std::transform(std::copy_if(vec.begin(), vec.end(), std::back_inserter(result), [](int x) { return x > 2; }), result.begin(), result.end(), [](int x) { return x * 2; });
  • 1
  • 2
  • 3

在这个例子中，使用 Lambda 表达式使代码更加简洁，算法的意图更加明确，并且减少了参数传递的复杂性。

总的来说，Lambda 表达式通过提供一种简洁的方式来定义和使用匿名函数，有助于提高 STL 算法使用的代码质量。

4.在实际项目中，如何选择合适的STL算法与Lambda表达式结合使用？

在实际项目中，选择合适的 STL 算法与 Lambda 表达式结合使用，可以提高代码的可读性、简洁性和效率。以下是一些指导原则：

  1. 明确需求：

    • 首先明确你要解决的问题是什么，比如搜索、排序、转换、过滤等。

  2. 选择最合适的算法：

    • 根据需求选择最合适的 STL 算法。例如，使用 std::find_if 搜索元素，使用 std::sort 排序，使用 std::transform 转换数据等。

  3. 考虑性能：

    • 考虑算法的性能特点，如时间复杂度和空间复杂度，以及它们是否满足项目的性能要求。

  4. 简化代码：

    • 利用 Lambda 表达式简化代码，避免编写复杂的循环和条件语句。

  5. 保持可读性：

    • 确保 Lambda 表达式简洁明了，避免过于复杂的逻辑，以免降低代码可读性。

  6. 利用类型推导：

    • 利用 auto 关键字和 Lambda 表达式让编译器自动推导类型，减少模板代码的复杂性。

  7. 捕获外部变量：

    • 当需要外部变量时，合理使用捕获子句，避免不必要的数据复制。

  8. 使用尾置返回类型：

    • 在模板编程中，使用尾置返回类型可以简化 Lambda 表达式的声明。

  9. 避免副作用：

    • 如果 Lambda 表达式可能产生副作用，确保这些副作用是可控的，并且不会导致程序逻辑错误。

  10. 重用 Lambda 表达式：

    • 如果发现多个地方使用了相同的逻辑，考虑将其重构为函数或泛型 Lambda 表达式。

  11. 测试和验证：

    • 对使用 STL 算法和 Lambda 表达式的代码进行充分的测试，确保它们的正确性和性能。

4.1.示例

假设你正在处理一个项目，需要从一组字符串中找出所有包含特定子串的字符串，并将它们转换为大写。

不使用 Lambda 表达式：

std::vector<std::string> strings = {"hello", "world", "example", "test"};
std::vector<std::string> result;

for (const auto& str : strings) {
    if (str.find("ex") != std::string::npos) {
        result.push_back(str); // 这里只是复制，没有转换为大写
    }
}

// 另一个循环来转换为大写
for (auto& str : result) {
    std::transform(str.begin(), str.end(), str.begin(),
                   [](unsigned char c) { return std::toupper(c); });
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

使用 Lambda 表达式：

std::vector<std::string> strings = {"hello", "world", "example", "test"};
std::vector<std::string> result;

// 使用 std::copy_if 和 Lambda 表达式过滤并转换
std::copy_if(strings.begin(), strings.end(), std::back_inserter(result),
              [](const std::string& str) {
                  return str.find("ex") != std::string::npos;
              });

// 使用 std::transform 和 Lambda 表达式转换为大写
std::for_each(result.begin(), result.end(),
              [](std::string& str) {
                  std::transform(str.begin(), str.end(), str.begin(),
                                 [](unsigned char c) { return std::toupper(c); });
              });
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

在这个例子中，使用 Lambda 表达式使得代码更加简洁，并且将过滤和转换逻辑组合在一起，提高了代码的可读性和可维护性。

通过这些指导原则和示例，你可以在实际项目中更好地选择和使用 STL 算法与 Lambda 表达式的结合。

5.如何使用Lambda表达式进行多线程编程？

在 C++11 及更高版本中，可以使用 Lambda 表达式与多线程库结合进行多线程编程。C++11 标准引入了线程库（std::thread），它允许你创建并行执行的线程。Lambda 表达式由于其简洁性和灵活性，成为在多线程环境中定义线程任务的理想选择。

以下是使用 Lambda 表达式进行多线程编程的基本步骤：

5.1. 包含必要的头文件

#include 
#include
  • 1
  • 2

5.2. 创建线程

使用 Lambda 表达式作为线程的入口点：

std::thread t([]() {
    // 在这里执行的任务代码
    std::cout << "Hello from thread!" << std::endl;
});
  • 1
  • 2
  • 3
  • 4

5.3. 等待线程完成

在主线程中，确保等待子线程完成，以避免主线程提前退出导致子线程被意外终止：

t.join();
  • 1

5.4.完整示例

#include 
#include 

int main() {
    // 创建并启动线程
    std::thread t([]() {
        std::cout << "Hello from thread!" << std::endl;
    });

    // 在主线程中执行其他任务
    std::cout << "Hello from main thread!" << std::endl;

    // 等待线程完成
    t.join();

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

5.5.使用捕获子句

Lambda 表达式可以捕获主线程中定义的变量，这对于线程间的数据共享非常有用：

#include 
#include 

int main() {
    int x = 10;

    // 捕获变量x
    std::thread t([=]() {
        x += 5;
        std::cout << "Thread modifying x: " << x << std::endl;
    });

    // 等待线程完成
    t.join();

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

5.6.注意事项

  1. 数据竞争：当多个线程访问共享数据时，需要注意数据竞争的问题。可以使用互斥锁（std::mutex）来保护共享数据。

  2. 线程安全：确保在线程中使用的变量是线程安全的，或者通过适当的同步机制来保护它们。

  3. 资源管理：确保线程使用的资源在线程结束后能够正确释放，避免资源泄漏。

  4. 异常处理：线程中的异常需要妥善处理，因为线程中的未捕获异常将导致程序终止。

  5. 性能考虑：创建大量线程可能会导致性能问题，如上下文切换开销。合理规划线程数量和任务分配。

通过使用 Lambda 表达式，你可以简洁地定义线程任务，使得多线程编程更加直观和易于管理。

6.如何使用 Lambda 表达式进行线程间的通信？

在 C++ 中，使用 Lambda 表达式进行线程间通信通常涉及到线程同步和数据共享。以下是一些关键点和技巧：

  1. 使用互斥锁（std::mutex）：在多线程环境中，当多个线程需要访问共享数据时，使用互斥锁可以避免数据竞争和条件竞争。Lambda 表达式可以捕获互斥锁，并在线程函数中使用它来保护共享资源。

    std::mutex mtx;
std::thread t([&]() {
    std::lock_guard<std::mutex> lock(mtx);
    // 访问或修改共享资源
});
    • 1
    • 2
    • 3
    • 4
    • 5

  2. 使用条件变量（std::condition_variable）：条件变量允许线程在某些条件下挂起，并在条件满足时被唤醒。这通常与互斥锁一起使用。

    std::mutex mtx;
std::condition_variable cv;
bool ready = false;

std::thread t([&]() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });
    // 处理共享资源
});

// 在主线程中设置条件
{
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_one();
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

  3. 使用原子操作（std::atomic）：原子操作提供了一种无需使用互斥锁的方式来安全地在线程间传递数据。

    std::atomic<int> data(0);

std::thread t([&]() {
    int expected_value = 42;
    // 使用原子操作比较和交换值
    data.compare_exchange_strong(expected_value, 100);
});
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

  4. 使用线程安全的队列：可以使用线程安全的队列来在线程间传递消息或数据。

    std::queue<int> q;
std::mutex q_mtx;
std::condition_variable q_cond;

std::thread producer([&]() {
    std::lock_guard<std::mutex> lock(q_mtx);
    q.push(42);
    q_cond.notify_one();
});

std::thread consumer([&]() {
    std::unique_lock<std::mutex> lock(q_mtx);
    q_cond.wait(lock, [&](){ return !q.empty(); });
    int value = q.front();
    q.pop();
    // 处理 value
});
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

  5. 使用线程池：线程池可以帮助管理线程的生命周期，减少线程创建和销毁的开销，并可以方便地进行任务调度。

    std::vector<std::thread> pool;
for (int i = 0; i < 4; ++i) {
    pool.emplace_back([&]() {
        while (true) {
            // 执行任务
        }
    });
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

  6. 使用 Lambda 表达式简化线程创建：Lambda 表达式可以简化线程的创建和启动过程。

    auto task = []() {
    // 线程任务代码
};
std::thread t(task);
t.join();
    • 1
    • 2
    • 3
    • 4
    • 5

  7. 确保线程安全：在设计线程间的通信机制时，确保考虑线程安全，避免未定义行为。

  8. 使用 C++11 标准：确保编译器支持 C++11 或更高版本，以便使用 Lambda 表达式和多线程库。

通过上述方法，你可以在多线程程序中有效地使用 Lambda 表达式进行线程间通信和同步。

7.在多线程编程中，如何避免数据竞争和线程安全问题？

在多线程编程中，避免数据竞争和确保线程安全是至关重要的。以下是一些关键策略和技术：

  1. 使用互斥锁（Mutexes）：

    • 最常见的方法是使用互斥锁来保护对共享数据的访问。当一个线程访问共享资源时，它需要先获取锁，其他线程必须等待该线程释放锁后才能访问。
    std::mutex mtx;
mtx.lock();
// 访问或修改共享资源
mtx.unlock();
    • 1
    • 2
    • 3
    • 4

  2. 使用原子操作（Atomic Operations）：

    • std::atomic 提供了一种机制，使得对某些类型的操作是原子的，即不可分割的，这样可以避免使用锁。
    std::atomic<int> data;
data.fetch_add(1); // 原子地增加数据
    • 1
    • 2

  3. 使用条件变量（Condition Variables）：

    • 条件变量允许线程在某些条件成立之前挂起等待。它们通常与互斥锁结合使用。
    std::mutex mtx;
std::condition_variable cv;
bool ready = false;

std::thread t([&]() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [&](){ return ready; });
    // 处理共享资源
});

// 在主线程中设置条件
{
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all();
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

  4. 避免共享状态：

    • 如果可能，设计线程以避免共享状态。每个线程可以拥有自己的数据副本，从而避免竞争。

  5. 使用线程局部存储（Thread-Local Storage）：

    • 使用 thread_local 关键字声明变量，这样每个线程都会有自己的独立实例。
    thread_local int threadData;
    • 1

  6. 使用读写锁（Read-Write Locks）：

    • 如果读操作远多于写操作，读写锁允许多个线程同时读取，但写入时需要独占访问。
    std::shared_mutex rwMutex;
std::shared_lock<std::shared_mutex> lock(rwMutex);
// 执行读取操作
    • 1
    • 2
    • 3

  7. 使用信号量（Semaphores）：

    • 信号量用于控制访问有限资源的线程数量。

  8. 使用屏障（Barriers）：

    • 屏障用于同步多个线程，直到到达某个点所有线程都准备好了。

  9. 使用锁自由并发数据结构：

    • 锁自由（lock-free）或无锁（lockless）数据结构使用原子操作来保证线程安全。

  10. 避免死锁：

    • 确保以相同的顺序获取多个锁，使用锁超时，或避免嵌套锁来减少死锁风险。

  11. 使用标准库算法：

    • 使用如 std::async 或其他高级并发工具，它们可能提供了额外的抽象来简化线程安全操作。

  12. 彻底测试：

    • 使用工具如动态分析器、线程断言或模型检查器来查找并解决并发问题。

  13. 最小化锁持有时间：

    • 只在必要时持有锁，并尽可能缩短持有时间。

  14. 使用智能指针：

    • 避免裸指针共享，使用如 std::shared_ptr 来管理共享数据，以确保正确的内存管理。

通过采用这些策略，你可以有效地避免数据竞争和线程安全问题，编写更安全、更可靠的多线程程序。

8.Lambda表达式在并发编程中有哪些优势和局限性？

Lambda 表达式在并发编程中提供了一些有用的特性，但同时也存在一些局限性。以下是它们的优缺点：

8.1.优势

  1. 代码简洁：

    • Lambda 表达式提供了一种简洁的方式来定义内联的匿名函数，使得代码更加简洁和直观。

  2. 捕获上下文：

    • Lambda 表达式可以捕获周围作用域中的变量，这对于需要访问外部变量的线程任务非常有用。

  3. 类型推导：

    • Lambda 表达式的参数类型和返回类型可以由编译器自动推导，简化了类型声明。

  4. 灵活性：

    • Lambda 表达式可以方便地与 STL 算法结合使用，提供灵活的参数和返回值处理。

  5. 易于使用：

    • Lambda 表达式可以作为参数传递给线程函数，简化了线程的创建和启动过程。

  6. 支持泛型编程：

    • Lambda 表达式可以作为泛型编程的一部分，与模板一起使用，提高代码的复用性。

8.2.局限性

  1. 捕获列表的复杂性：

    • 对于复杂的数据结构，捕获列表可能会变得复杂，难以理解和维护。

  2. 内存管理：

    • 如果 Lambda 表达式捕获了对象的引用或指针，需要确保这些对象在线程执行期间有效，否则可能会导致悬挂引用或野指针。

  3. 异常处理：

    • Lambda 表达式中抛出的异常必须在 Lambda 表达式内部捕获，否则会导致线程崩溃。

  4. 调试难度：

    • 由于 Lambda 表达式是匿名的，调试时可能难以定位问题，尤其是在多线程环境中。

  5. 性能开销：

    • Lambda 表达式可能会引入额外的性能开销，尤其是在捕获大量变量或使用复杂捕获列表时。

  6. 限制了并行度：

    • 如果在 Lambda 表达式中使用了互斥锁或其他同步机制，可能会限制程序的并行度。

  7. 不适合长生命周期任务：

    • Lambda 表达式通常用于短小的任务，对于需要长时间运行的任务，使用专门的函数或类可能更合适。

  8. 资源限制：

    • 在 Lambda 表达式中，资源管理和释放需要特别小心，以避免资源泄漏。

8.3.示例

以下是使用 Lambda 表达式进行并发编程的示例：

#include 
#include 
#include 

int main() {
    std::vector<std::thread> threads;
    int x = 0;

    // 创建线程
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back([i, &x]() {
            x += i; // 危险：多线程同时修改 x 会导致数据竞争
        });
    }

    // 等待线程完成
    for (auto& t : threads) {
        t.join();
    }

    std::cout << "x = " << x << std::endl;

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

在这个示例中，Lambda 表达式用于创建线程，但由于多个线程同时修改共享变量 x，导致了数据竞争。

8.4.总结

Lambda 表达式在并发编程中提供了很多便利，但也需要谨慎使用，以避免潜在的问题。合理地设计线程任务，确保线程安全，并考虑性能和调试的需要，可以使 Lambda 表达式成为并发编程的有力工具。

关于作者

WeSiGJ
微信公众号
共同分享，共同交流， 共同学习!
注：本文转载自blog.csdn.net的WeSiGJ的文章"https://wesigj.blog.csdn.net/article/details/142745319"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！