Destructor not running

[ShamusVW]

Ok, thanks, I understand what you are meaning to use it for.
The way I was planning to do it is pass the object along to each class/object as needed.
So if I created a new object from the class where I first created the logger object (i.e. m_ErrorLog), I would then use: anotherObject = new className anotherObject(m_ErrorLog); <--- passing the object between other objects created
Then in the newObject, I will then just reference the logging method (logError), I wouldn't instantiate a new logger object again.

What I have read is that there is debate on the use of the Singleton class, and that there are "better" ways to do things.
I don't have enough experience and knowledge to have an opinion, but it seemed to me that if people were throwing into question using it, then I should look at other ways to do it.
Is my passing of objects around bad?

[anda_skoa]

My understanding with destructors is that they got called automatically when the object went out of scope as andy_skoa mentioned

Yep, they do.

however, when the application terminates, why is the error logger class's destructor not called?

Because the object that goes out of scope in your case is the pointer to your error logger, not the error logger itself.
The pointer is a primitive datatype (like an int), it doesn't have any destructor (it isn't a class, just an address value).

Surely the object gets destroyed when the application ends, and hence the destructor should be called?

No. Your application code never destroys the object, i.e. you never call delete on the pointer to the object.

---

Added after 10 minutes:

The way I was planning to do it is pass the object along to each class/object as needed.
So if I created a new object from the class where I first created the logger object (i.e. m_ErrorLog), I would then use: anotherObject = new className anotherObject(m_ErrorLog); <--- passing the object between other objects created
Then in the newObject, I will then just reference the logging method (logError), I wouldn't instantiate a new logger object again.

Sensible approach.

What I have read is that there is debate on the use of the Singleton class, and that there are "better" ways to do things.
I don't have enough experience and knowledge to have an opinion, but it seemed to me that if people were throwing into question using it, then I should look at other ways to do it.
Is my passing of objects around bad?

A singleton has a couple of properties/behaviors and it is sometimes used for only one of them and not always is that a good reason.

One thing a singleton is good at is the use case where there absolutely can only be one instance.
A singleton class' constructor is usually private, only the instance() method can create an object of the class.

Sometimes,however, singletons are just used like global variables, so the usual arguments against global variables apply.

Loggers often use it for a combination, i.e. both for the convenience of global access as well as having a central object that all logging passes through.
But I've also seen loggers being passed through, e.g. when applications have multuple loggers or components are allowed to create their own, local, loggers.

One thing with singletons is that their objects are often never explicitly destroyed or such explicit destruction needs to be added to the end of main()
(while instantiation is often implicit in the first call to the instance access function)

Cheers,
_

[ShamusVW]

Thank you Lesiok & Anda_skoa for your feedback on destructors, object passing and the Singleton pattern.
It has given me direction to investigate this further, as I need to brush up on destructors and when they run, and also deleting of objects.