代码随想录八股训练营第三十九天| C++

最新推荐文章于 2024-10-12 11:03:43 发布

朝闻dao

最新推荐文章于 2024-10-12 11:03:43 发布

阅读量720

点赞数 7

文章标签： c++

本文链接：https://blog.csdn.net/2401_86461473/article/details/142081198

版权

前言

一、说一下 lambda函数？

1.1.Lambda 函数的一般语法如下:

2.4.单例模式的变体：使用 std::call_once（C++11）:

总结

前言

在现代软件开发中，设计模式是解决常见问题的一种可重用方案。单例模式是其中的一种模式，它确保一个类只有一个实例，并提供一个全局访问点。此外，Lambda 函数在 C++11 及更高版本中提供了一种编写匿名函数的便捷方式，它们在需要简短函数对象时非常有用。

一、说一下 lambda函数？

在 C++ 中，lambda 函数（也称为 lambda 表达式）是一种便捷的匿名函数定义方式，它允许你在不定义传统函数的情况下创建函数对象。Lambda 函数在 C++11 标准中被引入，并且成为了 C++14 和 C++17 标准的一部分。Lambda 函数通常用于简短的操作，或者作为参数传递给函数，特别是那些接受函数对象作为参数的算法，如 std::sort、std::for_each 等。

1.1.Lambda 函数的一般语法如下:

capture：捕获子句，用于指定 lambda 函数可以从封闭作用域中捕获哪些变量。可以是值捕获（通过复制）、引用捕获（通过引用）或默认捕获（通过值或引用，取决于变量的类型）。
parameters：参数列表，与普通函数参数列表类似。
return_type：返回类型，如果 lambda 函数体中包含单一的返回语句，可以省略返回类型。
function body：函数体，包含 lambda 函数的代码。

[capture] (parameters) -> return_type {
    // function body
}

1.2.捕获子句：

值捕获：使用等号 = 后跟要捕获的变量列表。
引用捕获：使用 & 后跟要捕获的变量列表。
混合捕获：可以同时使用值捕获和引用捕获。
默认捕获：不写捕获子句时，默认不捕获任何变量。

#include <iostream>
#include <vector>
#include <algorithm>

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

    // 使用 lambda 表达式对向量进行排序
    std::sort(nums.begin(), nums.end(), [](int a, int b) {
        return a > b; // 降序排序
    });

    // 使用 lambda 表达式打印向量中的元素
    std::for_each(nums.begin(), nums.end(), [](int n) {
        std::cout << n << " ";
    });

    return 0;
}

//值捕获（Value Capture）
//在值捕获中，lambda 函数内部的变量是外部变量的副本。任何对这些变量的修改都不会影响原始变量。
int outer_var = 10;
auto lambda = [outer_var]() {
    std::cout << "Value capture: " << outer_var << std::endl;
    outer_var = 20; // 修改的是副本，不会影响 outer_var
};
std::cout << "Original value: " << outer_var << std::endl; // 输出 10
lambda(); // 输出 Value capture: 10，然后输出 Original value: 10

//引用捕获（Reference Capture）
//在引用捕获中，lambda 函数内部的变量是对外部变量的引用。对这些变量的修改会影响原始变量。
int outer_var = 10;
auto lambda = [&outer_var]() {
    std::cout << "Reference capture: " << outer_var << std::endl;
    outer_var = 20; // 修改的是原始变量
};
std::cout << "Original value: " << outer_var << std::endl; // 输出 20
lambda(); // 输出 Reference capture: 20，然后输出 Original value: 20

//混合捕获（Mixed Capture）
//可以同时使用值捕获和引用捕获。
int value_var = 1;
int& ref_var = value_var;
auto lambda = [value_var, &ref_var]() {
    std::cout << "Mixed capture - value: " << value_var << ", ref: " << ref_var << std::endl;
    value_var = 2;
    ref_var = 3;
};
std::cout << "Original value: " << value_var << ", ref: " << ref_var << std::endl; // 输出 Original value: 1, ref: 1
lambda(); // 输出 Mixed capture - value: 1, ref: 1，然后输出 Original value: 2, ref: 3

//默认捕获（Default Capture）
//如果不指定捕获方式，lambda 函数不会捕获任何外部变量。
int outer_var = 10;
auto lambda = [] {
    std::cout << "Default capture: " << outer_var << std::endl; // 错误：outer_var 在这里未定义
};
// lambda(); // 这将导致编译错误，因为 outer_var 没有被捕获

二、C++ 怎么实现一个单例模式？

单例模式是一种常用的设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。在 C++ 中实现单例模式有多种方法，下面介绍两种常见的实现方式：

2.1.懒汉式（线程不安全）:

这种方式在第一次使用时才创建实例，但它不是线程安全的。

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // 构造函数

public:
    // 禁止拷贝和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;

2.2.饿汉式（线程安全）:

这种方式在程序启动时就创建实例，它是线程安全的，但可能会增加程序启动时间。

class Singleton {
private:
    Singleton() {} // 构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值

public:
    static Singleton& getInstance() {
        static Singleton instance; // 局部静态变量
        return instance;
    }
};

2.3.双重检查锁定（线程安全）:

这种方式在第一次使用时才创建实例，并且是线程安全的。

#include <mutex>

class Singleton {
private:
    Singleton() {} // 构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值

    static Singleton* instance;
    static std::mutex mutex;

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

2.4.单例模式的变体：使用 `std::call_once`（C++11）:

这种方式使用 std::call_once 确保线程安全，并且延迟实例的创建。

#include <mutex>

class Singleton {
private:
    Singleton() {} // 构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值

    static Singleton* instance;
    static std::once_flag once;

public:
    static Singleton* getInstance() {
        std::call_once(once, []() {
            instance = new Singleton();
        });
        return instance;
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::once;

总结

Lambda 函数和单例模式都是现代 C++ 编程中的重要概念。Lambda 函数提供了一种灵活的方式来编写简短的匿名函数，而单例模式则是一种确保类只有一个实例的设计模式。在多线程环境中实现单例模式时，需要特别注意线程安全。C++11 提供了 std::call_once 和 std::once_flag 这样的工具来帮助我们以线程安全的方式实现单例模式，而 Lambda 函数则因其简洁和表达力而成为编写算法和处理数据集时的首选。通过合理运用这些特性，我们可以编写出既高效又安全的代码。