无需辅助函数，模板函数共享静态变量的替代实现方案？

我有一个可简化为如下形式的函数：

template<typename T>
void my_function(T value_in)
{
   static int my_number{};
   // 处理 my_number 和 value_in
   my_number++;
}

我希望每次调用函数时my_number都能递增。若这不是模板函数，该逻辑会符合预期，但由于项目中调用该函数时会基于T的类型生成多个函数实例（编译时生成？“生成”是恰当的表述吗？），实际行为不符合预期。

目前我的解决方案如下：

int static_number_incrementer()
{
   static int static_number{};

   return static_number++;
}

template<typename T>
void my_function(T value_in)
{
   int my_number = static_number_incrementer();
   // 处理 my_number 和 value_in
}

该方案可行，但我想知道是否有更“内置”的方法，无需创建第二个函数即可在my_function的原始实现中达成需求？

你遇到的核心问题是：模板函数的静态变量会随模板实例化类型独立存储——没错，编译器会为每个不同的T生成独立的my_function<T>实例，每个实例拥有自己的static int my_number，因此不同类型调用时无法共享递增状态。以下是几种无需额外独立函数的实现方式：

方案1：Lambda引用共享静态变量（C++11及以上） #

直接在模板函数内部用lambda返回全局唯一的静态变量引用，所有模板实例共享同一个计数器：

template<typename T>
void my_function(T value_in)
{
    // 所有模板实例共享同一个counter
    static int& my_number = []() -> int& {
        static int counter{};
        return counter;
    }();

    // 处理 my_number 和 value_in
    my_number++;
}

lambda内部的static counter是全局唯一的，无论T是什么类型，所有my_function<T>实例都会引用该变量，确保每次调用（无论参数类型）都能递增。

方案2：非模板辅助类封装（C++98及以上） #

如果需要兼容更早的C++标准，可以将共享计数器封装在非模板的辅助类中，避免额外函数：

namespace detail {
    struct SharedCounter {
        static int value;
    };
    int SharedCounter::value = 0;
}

template<typename T>
void my_function(T value_in)
{
    int& my_number = detail::SharedCounter::value;

    // 处理 my_number 和 value_in
    my_number++;
}

这种方式将共享变量封装在命名空间内的辅助类中，既保证了封装性，又能让所有模板实例访问同一个静态变量。

方案3：C++17 inline静态变量（最简洁） #

C++17支持inline static变量，可以直接在命名空间中定义，写法更简洁：

namespace detail {
    inline static int shared_counter{};
}

template<typename T>
void my_function(T value_in)
{
    int& my_number = detail::shared_counter;

    // 处理 my_number 和 value_in
    my_number++;
}

inline static确保变量仅被定义一次，所有模板实例共享该变量，无需额外的类或lambda。

内容的提问来源于stack exchange，提问作者cam.b