When using the Meyers singleton:
class Singleton
{
public:
static Singleton& instance()
{
static Singleton instance;
return instance;
}
void Hello()
{
std::cout <<"Hello!\n";
}
protected:
Singleton() = default;
~Singleton() {};
private:
Singleton(Singleton const&);
Singleton& operator=( Singleton const& );
};
You are able to call the instance as follow:
Singleton::instance().Hello();
or
Singleton& s = Singleton::instance();
s.Hello();
But I'm wondering if there is a way to block this:
Singleton::instance().instance();
How to avoid to call instance() as a method (with the .) and only support the static call with the :: ?
Is there a way to use static_assert, template enable_if or anything else?
First, I don't think this is a practical concern. Nobody is going to write Singleton::instance().instance().instance().Hello(). Or rather, if people are writing that on purpose, I think you have bigger problems. This is fine, as-is.
If you really want to prevent that, then you just have to move instance() outside of the class so it ceases to be a member function. There's nothing for you to assert or constrain, since you cannot tell if your static member function was called on an object or not (and you cannot overload a static member function with a non-static one taking the same argument list). Either you can write both Singleton::instance() and Singleton::instance().instance(), or neither.
Simplest is just:
class Singleton {
// ...
friend Singleton& make_singleton();
};
Singleton& make_singleton() {
static Singleton instance;
return instance;
}
Now it's just make_singleton().Hello(), and there's no other way to write that at all. This can be arbitrarily generalized by wrapping it in a singleton class template factory:
template <typename T>
struct SingletonFactory
static T& instance() {
static T instance;
return instance;
}
};
SingletonFactory<Singleton>::instance().Hello(); // ok
SingletonFactory<Singleton>::instance().instance().Hello(); // error
Related
I'm trying to implement singleton template which could instantiate (from template argument) object of the class by ctor with some set of the parameters.
The code below looks ordinary and working.
template <typename T>
class Singleton
{
public:
template<typename... Ts>
static T &instance(Ts &&...args)
{
static T instance{std::forward<Ts>(args)...};
return instance;
}
protected:
Singleton() = default;
~Singleton() = default;
Singleton(const Singleton &) = delete;
Singleton &operator=(const Singleton &) = delete;
};
there is an interesting question:
if we are trying to get the instance using different ctors, intuitively expected that is a single instance:
// create with T with some specific parameters
Singleton<MyClass>::instance(1, nullptr, "test").dosomething();
// ....
// use such version for simpler notation
// or where the paramters are not available
Singleton<MyClass>::instance().dosomething();
In C++ template terms, obviously the instances are a different due of different instantiations of template instance() function.
if we write "old style" singleton (Meyer's version) based on member pointer to the instance, it solves the problem as the instance will be outside of template class method.
So the question is - is there some technique to keep "reference-style" singleton and keep this outside of "instance()" function to prevent different instances ? or anything else?
You can store the instance in a static member. The advantage of the meyers singleton is that initialization of the instance is thread safe just by how a local static varible works. Though the same can be achieved differently. As also the static requires the implementation to use some sort of synchronization mechanism, I do not expect too much difference in terms of performance when an explicit synchronization mechanism is used. I use std::once here.
#include <memory>
#include <mutex>
#include <iostream>
template <typename T> class Singleton {
public:
template<typename... Ts> static T& instance(Ts &&...args) {
std::call_once(once,[&](){
_instance = std::make_unique<T>(std::forward<Ts>(args)...);
});
return *_instance;
}
protected:
static std::unique_ptr<T> _instance;
static std::once_flag once;
Singleton() = default;
~Singleton() = default;
Singleton(const Singleton &) = delete;
Singleton &operator=(const Singleton &) = delete;
};
template <typename T> std::unique_ptr<T> Singleton<T>::_instance;
template <typename T> std::once_flag Singleton<T>::once;
struct T {
int value;
T(int x) : value(x) { std::cout << "hello world" << std::endl; }
T() = default;
};
int main() {
std::cout << Singleton<T>::instance(42).value;
std::cout << Singleton<T>::instance().value;
}
Live Demo (note the -pthread, without it will segfault).
std::call_once ensures that only one thread enters the function and only reach the return when _instance is initialized. Effectively it is the same as the static local.
The caveat is that Singleton<T>::instance() only compiles when T has a default constructor, otherwise it not (https://godbolt.org/z/TMdGe16re). I felt that this is beyond the question being asked here and did not include a solution. You can optionally add a instance() overload that does not call the constuctor but throws an exception when _instance is not yet initialized for the case when T cannot be default constructed.
Last and least the usual dislaimer against the singleton pattern: Don't, blablablbla blablabla blablablubb, globals are evil, blablablubb.
Under these condition i wrote the next Singleton class :
1 - i want one and only one instance of the class to be present and to be accessible from the whole game engine .
2 - the Singleton is intensively used ( thousands times per frame) so i dont want to write an extra GetInstance() function , im trying to avoid any extra function call for performance
3 - one possibility is to let the GetInstance() be inlined like this :
inline Singleton* Singleton::GetInstance()
{
static Singleton * singleton = new Singleton();
return singleton;
}
but that will cause a reference problem , on each call there will be a new reference to the singleton , to fix that wrote in c++ :
class Singleton{
private:
static Singleton* singleton;
Singleton(){}
public:
static inline Singleton* GetInstance() // now can be inlined !
{
return singleton;
}
static void Init()
{
// ofc i have to check first if this function
// is active only once
if(singleton != nullptr)
{
delete singleton;
}
singleton = new Singleton();
}
~Singleton(){} // not virtual because this class can't be inherited
};
Singleton* Singleton::singleton = nullptr;
What are the possible problems i can face with this implementation ?
Your first implementation problem is a leak of the only new you call.
And the signature that force user to check pointer validity.
Your second implementation has even more problem as you require to use a 2-step initialization, and don't forbid copy/move/assignment.
Simply use Meyers' singleton:
class Singleton{
private:
Singleton() = default;
~Singleton() = default;
Singleton(const Singleton&) = delete;
Singleton operator&(const Singleton&) = delete;
public:
static Singleton& GetInstance()
{
static Singleton instance;
return instance;
}
};
In addition to #Jarod42's answer, I would like to point out that you could also implement a generic singleton by making template and use it in a CRTP class:
template<typename T>
class Singleton {
protected:
Singleton() = default;
~Singleton() = default;
Singleton(const Singleton&) = delete;
Singleton operator&(const Singleton&) = delete;
public:
static T& instance() {
static T instance;
return instance;
}
};
Then extend it:
struct MySingleton : Singleton<MySingleton> { /* ... */ };
Instead of a singleton, consider a namespace! Here's how I would do it:
// thing.h
namespace thing {
// public interface
int doSomething();
}
// thing.cpp
namespace thing {
namespace {
// private data and functions can go right here :-)
int private_data_ = 1234;
int doSomethingInternal() {
return private_data_ * 2;
}
}
// public interface
int doSomething() {
return doSomethingInternal();
}
}
Usage is simple like this:
int x = thing::doSomething();
No need for getInstance(), no memory leaks, and you can't accidentally make multiple instances.
but that will cause a reference problem , on each call there will be a new reference to the singleton
Incorrect; instead there will be a new class instance which is not the same as a reference. You will most likely end up leaking memory.
static Singleton* singleton;
Use a unique_ptr instead of a raw pointer. Compiler optimizations will devolve it into a raw pointer anyway, but now you're clearly telling the compiler what its lifespan should be.
class Singleton{
private :
static Singleton* singleton;
The default scope of a class is private; you don't need to explicity say private scope.
Singleton(){}
There is no need to provide an empty constructor when you have no other constructors in the class.
im trying to avoid any extra function call for performance
Compiled C++ will often inline such code anyway.
inline Singleton* GetInstance() // now can be inlined !
Make it static...?
~Singleton(){} // not virtual because this class can't be inherited
If your intent is to make it not inheritable, then add a final keyword to the class declaration. You can then remove the destructor.
I've got a Singleton implementation where I am not sure which drawbacks it contains. Could anybody tell me how good this implementation is?
template <class Child>
class Singleton {
public:
inline static Child& Instance() {
return Instance_;
}
Singleton(const Singleton&) = delete;
Singleton(Singleton&&) = delete;
Singleton& operator=(const Singleton&) = delete;
Singleton& operator=(Singleton&&) = delete;
protected:
Singleton() = default;
private:
static Child Instance_;
};
template <typename Child> Child Singleton<Child>::Instance_;
I know of a Singleton implementation by Scott Meyers that defines the static Instance_ inside the GetInstance() function.
inline static Child& Instance() {
static Child Instance_;
return Instance_;
}
But isn't there additional overhead involved, because it has to check every time the function is invoked whether Instance_ has already been initialized.
Your solution is prone to static initialization order fiasco.
A static class member is initialized together with all global static variables; before main(), in an unspecified order. If initialization of one static variable happens to reference another one, you get undefined behavior.
Using a static variable in function, however, gives you the special guarantee: the object will only be created when the function is executed for the first time. This means that you don't have to worry about initialization order (unless you create a cycle, obviously).
Regarding performance, the checking is implemented by compiler, so it's probably tuned extremely well. As always, if you're in doubt - benchmark.
I need a singleton implementation without using dynamic memory allocation. I tried to implement it like this:
// Singleton.hpp
class Singleton
{
public:
static Singleton& GetInstance();
private:
Singleton();
static Singleton& Instance;
};
// Singlton.cpp
Singleton& Singleton::GetInstance()
{
return Singleton::Instance;
}
Singleton::Singleton()
{
}
As I said this doesn't compiles. I read many articles, I tried to initialize static Singleton& Instance in different ways, but all I get is a new compilation errors. Why this doesn't work? And how to implement a singleton pattern without using dynamic memory allocation?
You need to declare the GetInstance method static as well, otherwise you can only call it on an existing object - and you can't create an existing object because the constructor is private.
P.S. instead of creating the instance as a static member of the class, you can make it a static local variable inside GetInstance.
P.P.S. I just noticed that your Instance variable is a reference that you didn't initialize - that won't work either. Here's my version:
Singleton & GetInstance()
{
static Singleton Instance;
return Instance;
}
Your definition of Instance should not be reference like Singleton& Instance; in the header. It needs to be Singleton Instance; as it is not a reference but an object.
You have declared Singleton::Instance in the header but not defined it in the source. You need to put Singleton Singleton::Instance; in the source file. Non-const static objects need to be defined in the source file.
You need to declare getInstance method as static so that you won't need an actual object to call it. When it is static, you may call it using Singleton::getInstance();.
This way:
class Singleton
{
public:
static Singleton& getInstance();
~Singleton();
private:
Singleton();
Singleton(Singleton&); // don't implement
void operator=(const Singleton&); // don't implement
};
#include "singleton.hpp"
Singleton& Singleton::getInstance()
{
static Singleton instance;
return instance;
}
Singleton::Singleton()
{
}
Singleton::~Singleton()
{
}
Edit:
Following your "OPP-way" of doing it, you just have to initialize your instance variable:
class Singleton
{
public:
static Singleton& getInstance();
~Singleton();
private:
Singleton();
Singleton(Singleton&); // don't implement
void operator=(const Singleton&); // don't implement
static Singleton instance;
};
Singleton Singleton::instance;
Singleton& Singleton::getInstance()
{
return instance;
}
Singleton::Singleton()
{
std::cout << "ctor" << std::endl;
}
Singleton::~Singleton()
{
}
Test with this:
int main() {
Singleton& s = Singleton::getInstance().getInstance();
s.getInstance();
}
The constructor will be called just once... But this way you loose the lazy initialization.
This is what I did for my singleton class:
I added a data member static int Count ; into my class.
So now I have :
a declaration static Singleton::Count = 0;
and the constructor:
Singleton()
{
Count++;
}
My getinstance is:
static Singleton GetInstance()
{
Singleton obj;
if ( Count == 1)
return obj;
}
I like to experiment around as I learn more about coding. I have a program that would only require a single instance of a struct for the life of it's runtime and was wondering if it's possible to create a singleton struct. I see lot's of information on making a singleton class on the internet but nothing on making a singleton struct. Can this be done? If so, how?
Thanks in advance. Oh, and I work in C++ btw.
A class and a struct are pretty much the same thing, except for some minor details (such as default access level of their members). Thus, for example:
struct singleton
{
static singleton& get_instance()
{
static singleton instance;
return instance;
}
// The copy constructor is deleted, to prevent client code from creating new
// instances of this class by copying the instance returned by get_instance()
singleton(singleton const&) = delete;
// The move constructor is deleted, to prevent client code from moving from
// the object returned by get_instance(), which could result in other clients
// retrieving a reference to an object with unspecified state.
singleton(singleton&&) = delete;
private:
// Default-constructor is private, to prevent client code from creating new
// instances of this class. The only instance shall be retrieved through the
// get_instance() function.
singleton() { }
};
int main()
{
singleton& s = singleton::get_instance();
}
Struct and class are in C++ almost the same (the only difference is default visibility of members).
Note, that if you want to make a singleton, you have to prevent struct/class users from instantiating, so hiding ctor and copy-ctor is inevitable.
struct Singleton
{
private:
static Singleton * instance;
Singleton()
{
}
Singleton(const Singleton & source)
{
// Disabling copy-ctor
}
Singleton(Singleton && source)
{
// Disabling move-ctor
}
public:
Singleton * GetInstance()
{
if (instance == nullptr)
instance = new Singleton();
return instance;
}
}
Conceptually, a struct and a class are the same in C++, so a making singleton struct is the same as making a singleton class.
The only difference between class and struct are the default access specifiers and base class inheritance: private for class and public for struct. For example,
class Foo : public Bar
{
public:
int a;
};
is the same as
struct Foo : Bar
{
int a;
};
So, there is no fundamental difference when it comes to singletons. Just make sure to read about why singletons are considered bad.
Here's a simple implementation:
struct singleton
{
static singleton& instance()
{
static singleton instance_;
return instance_;
}
singleton(const singleton&)=delete; // no copy
singleton& operator=(const singleton&)=delete; // no assignment
private:
singleton() { .... } // constructor(s)
};
First off, struct and class only refer to the default access of members. You can do everything with a struct that you can do with a class. Now if you were referring to POD structs, things get more complicated. You can't defined a custom constructor, so there's no way to enforce only a single object creation. However, there's nothing stopping you from simply only instantiating it once.
class and struct is almost a synonyms in C++. For singleton use case they are complete synonyms.