How to share global object in other modules?

[MiiNiPaa]

My code ——— your code

1 2 3 4

S::S(const S&) { assert(false && "Calling copy constructor!"); }

S::S(int argc, char** argv) { assert(false && "Calling copy constructor!"); }

find the difference.
YOu should implement parametrised constructor and disallow copy constructor. Not the other way 'round.

[h4ever]

This works

void S::init(int argc, char** argv)
    {	
     instance_ = instance_ ? instance_ : new S(argc, argv) ; 
     }
S::S(int argc, char** argv){}

and main() contains.

S::init(argc, argv);
S::I()->CLPars.ParseArgs(argc, argv);

not to call it in the constructor.

[h4ever]

Yet I am trying to fix the destructor:

#include "stdafx.h"
S* S::instance_ = nullptr;
void S::init(int argc, char** argv)
    {	
	if(!instance_)
	{
	instance_ = new S(argc, argv);
	std::atexit(deleteSingleton);
	}
     }

S* S::I()
    {
        if( !instance_ ) {
            throw std::logic_error("Not initialised");
            return nullptr;
        }
        return instance_;
    }
S::S(int argc, char** argv){}

S::S(const S&){
	assert(false && "Calling copy constructor!");
};
S::~S(){};
S::deleteSingleton()
	{ delete instance_; }

But I am getting error
error C3867: 'S::deleteSingleton': function call missing argument list; use '&S::deleteSingleton' to create a pointer to member

somehow. It's nonsense when i don't use any arguments in deleteSingleton().

[MiiNiPaa]

There is something terribly wrong here.
If you do not need to have argc and argv avaliable when first creating object, remove init function completely, make I() handle object creation and use default constructor.

If you need thaem, you should not pass them second time.
In your previous posts you wrote that you cannot use default constructor because you need to passs argc/argv but you do not use them in your latest code.

What exactly do you want? You ask something, I give you an answer, In your following question you do something contradicting your previous statemenst, I modify code to suit your new needs, then you do something completely different again.

[h4ever]

I originally used the argument in constructor of MyGlobalClass to parse the arguments of CL. Then you said that the singleton should wrap all (well, i am not sure if this is exactly what you said) so I thought that it should be in the constructor of the singleton. As far as I understand now, before I can call instance() the constructor must finished the process of creation of instance. This means I could not to place the code in construcor of singleton. I needed some time to understand is completely. So now I see how to do it without the need to pass the args to init.

[MiiNiPaa]

before I can call instance() the constructor must finished the process of creation of instance

Either that or it should create instance inside instance() using default constructor.

To create you singleton you have init() function. You can even add some default arguments to the instance() function making ugly, but working boilerplate around it.

SO there is severall approaches:
1)Use init(): use code you have now. call to CLPars.ParseArgs(argc, argv); should be inside Singleton constructor.

2) Initialize object in default state, then change it state by calling member functions:
Ditch init() function. Make default constructor for your object. Make instance() create new object if there isn't one.
Then call CLPars.ParseArgs(argc, argv); on it. So code will be

int main(int argc, char** argv)
{
    S::I()->CLPars.ParseArgs(argc, argv); //No init 

3) Make something like

S::I(int argc = 0, char** argv = nullptr)
{
    if (!instance_)
        if (!argv)
            throw logic_error("Invalid initialization");
        else
            instance_ = new S(argc, argv);
    return instance_;
}

And make your class to be initialized in parametrized constructor like in (1).
Usage:

int main(int argc, char** argv)
{
    S::I(argc, argv); //Initialization
    //...
    S::I(); //other calls 

Best approach is to design your class using only one constructor. Make sure everything works and you can create it using this constructor, then make it Singleton. It is easier to work with already working code.

[h4ever]

I have finished the simplification you suggested me. Here I have two approaches
1) Singleton with pointer

class S
{
  public: // public instance members
    static S* I();
	STAT Stat;
	
	std::vector<SRC> sources;
	std::vector<TARGET> destination;
	CLParser CLPars;
	FILE_ File;

private: // private instance members
    static S* instance_;
    S(); // implementation of constructor
	S::S(const S&);
	S::~S();
	S& operator= (const S&);
};

Implementaion:

#include "stdafx.h"
S* S::instance_ = nullptr;

S* S::I()
    {
		if(!instance_)
			instance_ = new S();
       return instance_;
    }

S::S(){}
S::~S(){};

S::S(const S&){
	assert(false && "Calling copy constructor!");
};

2) Using reference

/* Meyers Singleton */
class S
{
public:
    static S& I(); // instance

	STAT Stat;
	
    std::vector<SRC> sources;
	std::vector<TARGET> destination;
	CLParser CLPars;
	FILE_ File;

private:
    S();
    S(const S&);
    ~S();
	S& operator= (const S&);
    struct Params
    {
        int argc;
        char** argv;
    };
	static Params* param;
};

Implementation

#include "stdafx.h"

S & S::I() // instance
    {
        static S inst;
        return inst;
    }

S::S(){}
S::S(const S&){};
S::~S(){};

S::Params* S::param = nullptr;

Use:

_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
S::I()->CLPars.ParseArgs(argc, argv);
// or 
S::I().CLPars.ParseArgs(argc, argv);

Both printing leaks but I read that this is normal because Singleton stays in memory till the program finishs. I guess that the debug tool is not able to detect whether it is really freed or not.

[MiiNiPaa]

Meyers sngleton should not leak. Tat might be in your parse args implementation or bug in leak detector.

[h4ever]

Thanks a lot for your help. I was pretty nervous last day, coz this looked like never finish.