【C++】巧用静态变量与构造函数：一种非常规的求和实现

class Solution {
private:
    static int _i;
    static int _ret;

    class Sum {
    public:
        Sum() {
            _ret += _i;
            _i++;
        }
    };

public:
    int Sum_Solution(int n) {
        Sum a[n];  // 创建n个Sum对象
        return _ret;
    }
};

int Solution::_i = 1;
int Solution::_ret = 0;

第二段代码：独立类实现

cpp

复制代码

class Sum {
public:
    Sum() {
        _ret += _i;
        ++_i;
    }
    static int GetRet() {
        return _ret;
    } 
private:
    static int _i;
    static int _ret;
};

int Sum::_i = 1;
int Sum::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Sum arr[n];  // 创建n个Sum对象
        return Sum::GetRet();
    }
};

核心原理

1. 静态变量的特性

静态变量在程序的生命周期内只初始化一次
所有类的实例共享同一份静态变量副本
静态变量在类外进行定义和初始化

2. 构造函数的调用时机

每次创建类的实例时，都会自动调用构造函数
创建数组时，会为每个数组元素调用构造函数

3. 求和的实现逻辑

text

复制代码

当n=3时：
第1次构造：_ret = 0 + 1 = 1, _i = 2
第2次构造：_ret = 1 + 2 = 3, _i = 3
第3次构造：_ret = 3 + 3 = 6, _i = 4
最终返回：6 (即1+2+3)

关键特性详解

变长数组(VLA)

两段代码都使用了变长数组Sum arr[n]，这是C99标准引入的特性，在C++11及之后的标准中，部分编译器支持作为扩展。更标准的C++写法是使用动态内存分配：

cpp

复制代码

// 替代变长数组的方法
Sum* arr = new Sum[n];
delete[] arr;

静态成员函数

第二段代码中的GetRet()是静态成员函数，它可以：

不依赖类的实例直接调用
只能访问静态成员变量
没有this指针

潜在问题

1. 非线程安全

由于静态变量是共享的，在多线程环境下同时调用Sum_Solution会导致数据竞争。

2. 只能计算一次

静态变量在程序运行期间保持状态，这意味着：

第二次调用Sum_Solution时，会从上一次结束的状态继续
需要手动重置静态变量才能再次使用

3. 非标准特性

变长数组不是标准C++特性，可移植性较差。

改进建议

线程安全版本

cpp

复制代码

class ThreadSafeSum {
public:
    static int Sum(int n) {
        static std::mutex mtx;
        std::lock_guard<std::mutex> lock(mtx);
        
        static int i = 1;
        static int ret = 0;
        int original_ret = ret;
        
        // 临时对象进行累加
        struct Temp {
            Temp(int& r, int& i) : ret(r), idx(i) {}
            ~Temp() { ret += idx++; }
            int& ret;
            int& idx;
        };
        
        for (int j = 0; j < n; ++j) {
            Temp temp(ret, i);
        }
        
        int result = ret - original_ret;
        ret = original_ret;  // 恢复原值
        return result;
    }
};

更清晰的传统实现

cpp

复制代码

class Solution {
public:
    // 方法1：循环
    int Sum_Solution_Loop(int n) {
        int sum = 0;
        for (int i = 1; i <= n; ++i) {
            sum += i;
        }
        return sum;
    }
    
    // 方法2：递归
    int Sum_Solution_Recursion(int n) {
        return n <= 0 ? 0 : n + Sum_Solution_Recursion(n - 1);
    }
    
    // 方法3：公式
    int Sum_Solution_Formula(int n) {
        return n * (n + 1) / 2;
    }
};

应用场景分析

虽然这种实现方式在实际开发中不常见，但在某些特定场景下有参考价值：

面试题：考察对C++构造函数、静态变量等特性的理解
教学示例：展示C++语言特性的灵活运用
特殊框架：在某些需要自动注册或计数的框架中，类似的模式会被使用

总结

这段代码展示了C++的几个重要特性：

静态成员变量的生命周期和共享特性
构造函数的自动调用机制
通过对象数组批量触发构造函数

然而，在实际工程中，我们更推荐使用传统的循环、递归或数学公式来实现求和功能，因为：

代码意图更清晰
性能更好（没有不必要的对象构造）
避免静态变量带来的副作用
更好的可维护性和可读性

这种"花式"实现虽然有趣，但更多的是作为对语言特性深入理解的练习，而非实际应用的最佳实践。

记住：优秀的代码应该是简洁、清晰、易于理解和维护的。