静态局部变量被重新初始化

Question

我有一个虚拟单例，我想实现getInstance()静态函数，但是每次调用时，静态对象都会重新初始化，所以每次都得到一个新实例，任何帮助将不胜感激 - 这让我非常困惑。

我想要实现的方法的类：

class Pc : public Machine 
{ 
    private: 
    ... members ... 

    public: 
    static Pc* getInstance(); 

    Pc() {}; 
    virtual ~Pc() {} 

    ... other functions ... 
}; 

的父类：

从机

class Machine 
{ 
    public: 
    static Machine* getInstance(); 

    Machine() { } 
    Machine(const Machine&) = delete; 
    virtual ~Machine() { } 

    ... methods ... 

    void operator=(const Machine&) = delete; 
}; 

大桥 - > PC单

Machine* Machine::getInstance() 
{ 
    return Pc::getInstance(); 
} 

我有两套的PC代码，我相信应该工作，我目前的解决方法代码...

非工作代码：

Pc* Pc::getInstance() 
{ 
    static Pc* pc = new Pc(); 
    return pc; 
} 

工作（但bodged）getInstance()代码：

static Pc* pc = nullptr; 
Pc* Pc::getInstance() 
{ 
    if(pc == nullptr) { 
     pc = new Pc(); 
    } 
    return pc; 
} 

虽然两者编译成功，突破后指向我的代码，我可以看到我的期望代码返回相同指针，但是在操作对象之后，第二次调用返回一个新对象，导致我相信静态变量已经被再次初始化。

编译与标志：

-ffreestanding -Wall -Wextra -fno-exceptions -fno-rtti -std=gnu++11 -lgcc 

（这是一个OS项目）

Answer 1

好的！头部搔抓3天后，我发现错误的原因！如果你使用--ffreestanding来编译你的代码，GCC希望你能为你自己提供一些功能，否则任何人都会有这个错误（已经非常模糊），我已经把我在下面使用的代码（非常感谢osdev.org这个代码！ ）

__extension__ typedef int __guard __attribute__((mode(__DI__))); 

extern "C" int __cxa_guard_acquire(__guard* g) 
{ 
    return !*(char*)(g); 
} 

extern "C" void __cxa_guard_release(__guard* g) 
{ 
    *(char *)g = 1; 
} 

extern "C" void __cxa_guard_abort (__guard*) 
{ 
} 

Answer 2

......导致我相信静态变量再次被初始化。

这可能是你允许公开构建Machine和Pc实例（或复制）条款的权利的看法。

那么，你的代码在这里

Pc* Pc::getInstance() { 
    static Pc* pc = new Pc(); 
    return pc; 
} 

和方法的签名

static Machine* getInstance(); 

最好是

Pc& Pc::getInstance() { 
    static Pc theInstance; 
    return theInstance; 
} 

static Machine& getInstance(); 

也使默认情况下，拷贝构造函数，赋值运算符两个私人课Machine和Pc。 因此仅供参考变量可以被实际使用，访问单个实例

Machine& mach = Pc::getInstance(); 
Machine m2; // Fails to compile 

UPDATE：
但我在这里看到一个普遍的问题，使您的整个设计有点怀疑：

Machine& Machine::getInstance() { 
    return Pc::getInstance(); 
} 

这使得Machine类依赖于它的派生类，这使得基类完全无用。

---

如何使用模板类来解决这个问题？

template<class Derived> 
class Machine { 
public: 
    static Derived& getInstance() { 
      static Derived theInstance; 
      return theInstance; 
    } 
protected: 
    Machine() { 
     Derived* self = static_cast<Derived*>(this); // Ensure that Derived 
                 // inherits from Machine 
     (void)self; // suppress compiler warning for unused variable 
    } 
private: 
    Machine(const Machine&); 
    Machine& operator=(const Machine&); 
}; 

class Pc : public Machine<Pc> { 
    friend class Machine<Pc>; 
    Pc() : Machine<Pc>() {} 
}; 

int main() { 
    Pc& pc = Pc::getInstance(); // Get a reference of the Pc singleton 
    return 0; 
} 

查看fully working sample here。

---

至于你的-ffreestanding编译器选项中提到：

首先，它是一个C编译器选项（应该不会影响到你的C++代码），第二次我在GCC documentation

发现GCC的目标是作为一个独立的独立实现来使用，或作为合规托管实现的编译器。默认情况下，它将作为托管实现的编译器，将STDC_HOSTED定义为1，并假定使用ISO C函数的名称时，它们具有标准中定义的语义。为了使其充当独立环境的独立实施，请使用“免费”选项;它会将STDC_HOSTED定义为0，并且不会对标准库中函数名的含义做出假设，但有以下例外情况。要构建一个操作系统内核，您可能仍然需要为连接和启动做出自己的安排。见Options Controlling C Dialect。

这并没有给我任何关于本地静态初始化的未定义行为的观点。