如何在VS2017中允许单例构造函数重新进入/传递？

Question

I've been porting some c++ app from Visual Studio 2013 to Visual Studio 2017. Aside from the plethora of new warnings that I had to fix, the compilation and linking went okay.

However, when running the app, it 'stalled' when trying to re-enter the constructor of a singleton (when successive function calls form a loop back to the constructor). It seems that this behaviour was okay in VS2013, but is no longer valid in VS2017. There is no error message.

I'm aware of all the bad things related to singletons, and that there should at least not be loops. The question is not there.

Is there a way to tell the VS2017 compiler that I'd like to shoot myself in the foot, and allow the same behaviour that was there in VS2013?

I don't have access to the code that causes this behaviour because it comes from a third-party library, this is why I can't 'just fix it', unfortunately.

Here is an example which works in VS2013, but doesn't work in VS2017:

main.cpp

#include "Singleton.h";

int 
main( void )
{

  std::cout << "let's do this!" << std::endl;
  int two = Singleton::GetReference().getTwo();
  std::cout << "ok" << std::endl;
  return 0;
}

Singleton.h

#pragma once

class Stuff;

class Singleton
{
public:
  static Singleton& GetReference();

  int getTwo() { return 2; }

private:
  Singleton();

  Stuff* stuff;
};

Singleton.cpp

#include "Singleton.h"
#include "Stuff.h"

Singleton& 
Singleton::GetReference() { 
  static Singleton theInstance; 
  return theInstance; 
}

Singleton::Singleton()
{
  stuff = new Stuff();
}

Stuff.h

#pragma once

class Stuff
{
public:
  Stuff();
private:
  int two;
};

Stuff.cpp

#include "Stuff.h"
#include "Singleton.h"

Stuff::Stuff()
{ 
  two = Singleton::GetReference().getTwo();
}

In the code above, when step-by-step debugging, the first time we get on the line static Singleton theInstance; will work as expected, but the second time, a F11 will go to the file thread_safe_statics.cpp , into the method extern "C" void __cdecl _Init_thread_header(int* const pOnce) . A Shift+F11 will exit the method and the program will wait indefinitely at the line specified (observed when pausing the program from the debugger).

---

PS

This issue probably occurs in Visual Studio 2015 too, as the documentation linked from the accepted answer mentions VS2015.

Answer 1

/Zc:threadSafeInit-

The general "Conformance" page is MSDN: Conformance , which details which new features you can disable.

I needed the code for sizedDealloc, where my new compiler was creating a sized new operator for a library which broke older compiled expectations.

As this is a compile flag, at least some of the code would be in your control, and you should be able to unravel the beast.

The constructor Stuff::Stuff is calling a function on an incompletely constructed object.

That would create "Undefined behavior". If the value "2" is not set till the end of the constructor (for example).

Probably the Singleton needs to be split into 2, one which delivers the early static data (eg 2).

The second which delivers the held object Stuff. Stuff would only rely on the first, which would break the deadlock.

Alternatively, a second constructor to Stuff which told it which object to use, and was called from the Singleton::Singleton

The MSDN article to disable "Magic Statics" MSDN : disable threadsafe static initialization