当前位置：首页 > news >正文

c++ 基础题目lambda

news 来源：原创 2025/5/13 19:07:34

1. auto lambda = [](double x) { return static_cast<int>(x); }; 是匿名函数对象 ,不可直接声明

a.可以赋值给一个与其类型兼容的 std::function 类型的对象 std::function<int(int, int)> lambda = [](int x, int y) { return x + y; };

b.使用具体的 lambda 类型（函数指针） int (*lambda1)(int, int) = [](int x, int y) { return x + y; };

c. 推导类型decltype([](int x, int y) { return x + y; }) lambda = [](int x, int y) { return x + y; };

decltype 用于推导一个表达式的类型，而不是像 auto 那样推导变量的类型

int x = 5;
double y = 2.5;
decltype(x + y) z = x + y;  // decltype(x + y) 等同于 double
std::cout << z << std::endl;  // 输出 7.5

2. 什么样的lambda不能复制给function

1. 捕获非复制对象的 lambda

std::unique_ptr<int> ptr = std::make_unique<int>(42);

    // 捕获了一个不可复制的对象 std::unique_ptr
    auto lambda = [ptr]() { return *ptr; };

std::unique_ptr<int> 是不可复制的，它的移动语义导致 lambda 无法被复制。因此，std::function 也无法复制该 lambda ,可以改为捕获指针或其他可复制的对象。

auto lambda = [ptr = std::move(ptr)]() { return *ptr; };

2.捕获了外部局部变量，并且该变量是不可复制的（例如，捕获了一个带有删除拷贝构造函数的类型），就不能将其赋值给 std::function

#include <iostream>
#include <functional>

struct NonCopyable {
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;  // 删除拷贝构造函数
};

int main() {
    NonCopyable nc;
    auto lambda = [nc]() { return 42; };  // 捕获了一个不可复制的对象

    // 无法将 lambda 赋值给 std::function，因为它捕获了不可复制的对象
    std::function<int()> func = lambda;  // 编译错误

3 . lambda 捕获的对象存在哪里

是由编译器在内存中为 lambda 创建的闭包对象所持有的。具体来说，lambda 捕获的对象被存储在一个类的成员变量中，这个类通常被称为闭包类型。

class lambda_class {
private:
    int x;  // 捕获的对象

public:
    lambda_class(int x) : x(x) {}
    void operator()() {
        std::cout << "Captured value: " << x << std::endl;
    }
};

int main() {
    int x = 10;
    lambda_class lambda(x);  // 创建 lambda 对象
    lambda();  // 调用 lambda
    return 0;
}

lua 有几种原表

__index。用于访问表中不存在的字段时触发。可以用来实现表的继承或委托

__newindex 用于设置表中不存在的字段时触发。可以用于限制或控制表字段的赋值。

__call 当表被作为函数调用时触发。这允许你让表表现得像函数一样。

__tostring 当表被转换为字符串时触发。通常在使用 print() 或 tostring() 函数时，Lua 会调用 __tostring 元方法。

__add, __sub, __mul, __div, __mod, __pow, __concat, __len, __eq, __lt, __le 等运算符元方法

5. realloc 会尝试调整内存块的大小：

扩展内存：
- 如果当前内存块后面有足够的空闲空间，realloc 会直接扩展内存块，而无需移动数据。
- 如果没有足够的空闲空间，realloc 会分配一块新的内存，将原有数据复制到新内存中，然后释放旧内存。

6. 在 MySQL 中，"回表"（也叫做"二次查表"）是指在使用覆盖索引时，如果查询需要的字段不在索引中，那么就需要通过索引中的记录再次去查询对应的数据表，从而获取那些没有包含在索引中的字段值。

为了更好理解，先简要了解下 MySQL 索引的相关概念：

覆盖索引：是指查询时，所需要的所有字段都在索引中，查询不需要再访问数据表（即回表操作）。
非覆盖索引：是指查询需要的字段不完全在索引中，部分数据仍然需要通过索引中的主键或唯一索引回到数据表中查找。

举个例子

假设 users 表有如下字段：id（主键）、name 和 age，并且你创建了一个索引 idx_name，仅包含 name 字段。如果你执行以下查询：

ELECT id, name, age FROM users WHERE name = 'Alice';

MySQL 会首先利用 idx_name 索引查找符合条件的记录（即 name = 'Alice'）。
由于查询还需要 id 和 age 字段，而这些字段不包含在 idx_name 索引中，因此 MySQL 会通过索引中的主键值回到数据表中，查找对应的行数据并返回结果。

怎么避免回表

1. 使用覆盖索引

CREATE INDEX idx_name_age ON users(name, age);

2. 使用复合索引

如果查询涉及多个字段，最好创建一个复合索引，索引包含查询的所有字段，避免 MySQL 在查询过程中回表。

示例：

假设你频繁查询 name 和 age 字段，可以创建如下复合索引：

CREATE INDEX idx_name_age ON users(name, age);

当你执行以下查询时：

SELECT name, age FROM users WHERE name = 'Alice' AND age = 25;

MySQL 会使用复合索引 idx_name_age，通过索引直接返回数据，避免回表。

3. 合理选择查询字段

4. 使用主键查询

8. 模版是拷贝代码的.

#include <iostream>

template <typename T>
class t {
public:
    static int staticVar;  // 静态成员变量
    T a;
};
// 静态成员变量的定义
template <typename T>
int t<T>::staticVar = 0;

int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    
    t<float> c;
    c.staticVar = 99;
    
    t<int> b;
    b.staticVar = 100;
 
    printf("%d \n", c.staticVar);
    return 0;
}

互斥锁在父子进程中也是独立的,锁了的状态也会被复制,,需要在各自的进程解锁

#include <iostream>


#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

pthread_mutex_t mutex;  // 定义互斥锁

int main() {
    pid_t pid;

    // 初始化互斥锁
    pthread_mutex_init(&mutex, NULL);

    // 父进程锁定互斥锁
    pthread_mutex_lock(&mutex);
    printf("Parent process: Mutex locked.\n");

    // 使用 fork 创建子进程
    pid = fork();

    if (pid == -1) {
        // 错误处理
        perror("fork failed");
        exit(1);
    }

    if (pid == 0) {  // 子进程
        // 子进程在这里会等到父进程锁定互斥锁
        printf("Child process: Waiting to unlock the mutex...\n");
        // 子进程解锁互斥锁
        pthread_mutex_unlock(&mutex);
        printf("Child process: Mutex unlocked.\n");
        exit(0);
    } else {  // 父进程
        // 父进程在这里等待子进程执行完毕
        wait(NULL);  // 等待子进程结束
        printf("Parent process: Mutex still locked after child exits.\n");

        // 父进程完成任务后解锁互斥锁
        pthread_mutex_unlock(&mutex);
        printf("Parent process: Mutex unlocked.\n");

        // 销毁互斥锁
        pthread_mutex_destroy(&mutex);
    }

    return 0;
}