C++静态类型成员变量的初始化顺序(单例模式)

本文讨论了静态成员变量的初始化和析构顺序的不确定性,指出这可能成为隐藏的程序隐患。局部静态变量的构造和析构顺序依赖于实际执行路径,这在多线程和复杂程序中可能导致不可预测的行为。为避免问题,建议尽量避免使用局部静态变量,或者确保它们之间构造和析构的独立性。此外,文章通过一个单例模式的例子说明了相关问题,并提供了测试程序以加深理解。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

对编译器来说,静态成员变量的初始化顺序和析构顺序是一个未定义的行为

#include <string>
#include <iostream>
using namespace std;
class Base{
public:
    static int b;
    static int a;
    
};
int Base::b = 2;
int Base::a = b + 1;




 
int main()
{
    Base base;
    cout <<"Base::a="<< Base::a << endl;
    cout <<"Base::b="<< Base::b << endl;
 
    return 0;
}


请添加图片描述

6 7 18 19 行怎么修改值都一样可见静态类型成员变量的初始化顺序和编译器和有关
如下文所说:https://wenku.baidu.com/view/60a101842b4ac850ad02de80d4d8d15abe2300da.html
理解在⼀个应⽤程序内部,静态变量的构造/析构顺序。其中,对于全局静态变量,视编译器的实现⽽定(⼀种⽅式是根据字
母顺序来决定);对于有依赖关系的,那么视依赖关系⽽定。⽽对于局部静态变量来说,问题就开始复杂了。这也正是本⽂论述的重点。
⾸先,要理解编译器是如何实现局部静态变量的语法特性的。从语法上来看,局部静态变量与全局静态变量最⼤的不同在于构造时机——当
且仅当程序执⾏路径⾸次达到局部静态变量的定义处才出发构造。注意是⾸次。印象中编译器是通过添加⼀个标识变量(当然这个变量⼀定
是全局静态的)来实现的(即每次程序执⾏到时,⾸先检查这个标志变量),如此来确保调⽤时构造且只构造⼀次的特性。那么反过来看局
部静态变量的析构,编译器会维护⼀个析构函数的函数指针栈,⼀旦构造完成,就会把相应的析构函数指针放到这个栈中。当程序结束后,
由编译器⽣成的doexit函数会逐个调⽤这些析构函数,完成进程结束前的扫尾⼯作。基于此,很显然,对于分布在程序各处的静态局部变
量,其构造顺序取决于它们在程序的实际执⾏路径上的先后顺序,⽽析构顺序则正好与之相反。
很简单,不是么?可为什么说是隐藏的坑呢,问题在于:

⼀⽅⾯是因为程序的实际执⾏路径有多个决定因素(例如基于消息驱动模型的程序和多线程程序),有时是不可预知的; 另⼀⽅⾯是因为局部静态变量分布在程序代码各处,彼此直接没有明显的关联,很容易让开发者忽略它们之间的这种关系(这是最坑的地 ⽅)。

既然提出问题,那么就讨论应对之道:
(1)最简单的,避免使⽤局部静态变量,将变量的声明周期控制在开发者⼿中;
(2)如果确有需要,那么尽量确保局部静态变量之间构造和析构是彼此独⽴互不相关的,换句话说,它们可以以任意的顺序被构造和析
构;
设计模式里的单例模式就有静态变量互相引用从而系统奔溃。
测试程序

#include <string>
#include <iostream>
using namespace std;
class Log
{
public:
    static Log* GetInstance()
    {
        static Log oLog;
        return &oLog;
    }
 
    void Output(string strLog)
    {
        cout<<strLog<<(*m_pInt)<<endl;
    }
private:
    Log():m_pInt(new int(3))
    {
    }
    ~Log()
    {cout<<"~Log"<<endl;
        delete m_pInt;
        m_pInt = NULL;
    }
    int* m_pInt;
};
 
class Context
{
public:
    static Context* GetInstance()
    {
        static Context oContext;
        return &oContext;
    }
    ~Context()
    {
        Log::GetInstance()->Output(__FUNCTION__);
    }
 
    void fun()
    {
        Log::GetInstance()->Output(__FUNCTION__);
    }
private:
    Context(){}
    Context(const Context& context);
};
 
int main(int argc, char* argv[])
{
    Context::GetInstance()->fun();
    return 0;
}


参考博客:https://www.freesion.com/article/7937607333/

C++中,静态成员变量初始化通常需要在类的定义外进行。以下是一种常见的初始化方法: ```cpp // 在类的定义中声明静态成员变量 class MyClass { public: static int myStaticVariable; }; // 在类的定义外进行初始化 int MyClass::myStaticVariable = 0; ``` 在上面的示例中,我们在类的定义内声明了一个静态成员变量 `myStaticVariable`,然后在类的定义外用 `MyClass::` 来指定作用域,进行初始化赋值。 请注意,在C++11之前,如果静态成员变量是一种非整数类型(例如类对象),则需要在类的定义外调用其构造函数进行初始化。 ```cpp class MyClass { public: static std::string myStaticString; }; std::string MyClass::myStaticString = "Hello, World!"; // C++11之前的写法 ``` 从C++11开始,还可以通过在类的定义内使用静态成员变量的初始值来进行初始化: ```cpp class MyClass { public: static int myStaticVariable = 42; // C++11以后的写法 }; ``` 这种方法只适用于整数类型的静态成员变量。对于其他类型,仍然需要在类的定义外进行初始化。 需要注意的是,在多个文件中使用静态成员变量时,只能在一个文件中进行定义和初始化,其他文件需要使用 `extern` 关键字来声明该静态成员变量。 ```cpp // MyClass.h class MyClass { public: static int myStaticVariable; }; // MyClass.cpp int MyClass::myStaticVariable = 0; // main.cpp #include "MyClass.h" extern int MyClass::myStaticVariable; ``` 这样就可以在不同的源文件中使用同一个静态成员变量 `myStaticVariable` 了。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值