C++：如何确保Lambda或函数体内的static字段仅初始化一次？

嘿，这个问题问到点子上了——static变量的初始化安全性在多线程场景下特别重要，而且没人想让初始化逻辑重复执行浪费资源。我来给你把各种情况说清楚：

从C++11开始，标准直接保证了函数内的static局部变量是线程安全的延迟初始化：第一次执行到变量声明的代码行时，初始化逻辑只会执行一次，哪怕多个线程同时进入这个函数，编译器也会自动生成同步代码来保护这个过程，完全不用你手动加锁。

举个直观的例子：

#include <iostream>
#include <string>

void print_greeting() {
    // 这个初始化逻辑（包括lambda里的输出）只会执行一次
    static std::string greeting = [](){
        std::cout << "Initializing greeting..." << std::endl;
        return "Hello, Stack Overflow!";
    }();
    std::cout << greeting << std::endl;
}

int main() {
    print_greeting();
    print_greeting(); // 第二次调用不会触发初始化
    return 0;
}

运行这段代码，你只会看到一次Initializing greeting...的输出，完美符合“仅执行一次”的要求。

Lambda本质上是个匿名函数对象，它内部的static变量和普通函数的static局部变量遵循完全相同的规则——C++11+下同样是线程安全的、仅初始化一次。

哪怕你把Lambda复制多份，static变量也属于Lambda的类型，而不是某个实例，所以初始化只会触发一次：

#include <iostream>

int main() {
    auto counter_lambda = [](){
        static int count = [](){
            std::cout << "Initializing counter..." << std::endl;
            return 0;
        }();
        return ++count;
    };

    auto lambda_copy = counter_lambda; // 复制Lambda

    std::cout << counter_lambda() << std::endl; // 输出1
    std::cout << lambda_copy() << std::endl;    // 输出2，初始化没重复执行
    return 0;
}

这里不管调用原Lambda还是它的副本，Initializing counter...只会打印一次。

如果你还在维护旧标准的代码，那编译器不保证static局部变量的线程安全初始化，这时候就得手动用互斥锁来保护：

#include <iostream>
#include <string>
#include <mutex>

void old_style_init() {
    static std::string data;
    static bool is_initialized = false;
    static std::mutex init_mutex;

    // 每次进入都先加锁，再检查是否已初始化
    std::lock_guard<std::mutex> lock(init_mutex);
    if (!is_initialized) {
        data = "Old-school initialized data";
        std::cout << "Old-style initialization..." << std::endl;
        is_initialized = true;
    }
    std::cout << data << std::endl;
}

注意：别用双重检查锁定（DCLP），C++03里因为指令重排的问题，这种写法是不安全的，老老实实加锁检查最稳妥。

如果不想依赖延迟初始化，而是想手动控制初始化时机（比如程序启动时就完成，或者在某个特定阶段触发），可以用std::call_once——这是C++11引入的工具，专门用来保证某个函数仅执行一次，线程安全：

#include <iostream>
#include <string>
#include <mutex>

std::once_flag init_flag;
std::string global_config;

void load_config() {
    global_config = "Loaded from config file";
    std::cout << "Config loaded once..." << std::endl;
}

void use_config() {
    std::call_once(init_flag, load_config);
    std::cout << "Using config: " << global_config << std::endl;
}

int main() {
    use_config();
    use_config(); // 不会重复加载
    return 0;
}

这个方法不管是在普通函数还是Lambda里都能用，灵活性拉满。

内容的提问来源于stack exchange，提问作者One Two Three