My Base class is Singleton having protected c'tor. Now, I can derive another class from it but I cannot create instance of that Base class inside functions of derived class. This is expected behavior as per my design. But I like to know is it correct by C++ standards or just my compiler specific behavior? (So that I shouldn't face issues if I want to port this code in future)
class Singleton
{
protected:
Singleton() {}
public:
Singleton * GetInstance()
{
static Singleton* InstanceCreated = NULL ;
if (!InstanceCreated)
InstanceCreated = new Singleton ;
return InstanceCreated ;
}
};
class Deringlton : public Singleton
{
public:
Deringlton()
{
Singleton * pSing ;
// pSing = new Singlton ; // Cannot create object of singlton
// (Despite class is derived from singlton)
}
};
I think a better way to provide a generic singleton implementation is to use the CRTP and directly inheriting from that template. That means every class automagically implements the singleton pattern only inheriting from the CRTP base:
template<typename DERIVED>
class generic_singleton
{
private:
static DERIVED* _instance;
static void _singleton_deleter() { delete _instance; } //Function that manages the destruction of the instance at the end of the execution.
protected:
generic_singleton() {}
virtual ~generic_singleton() {} //IMPORTANT: virtual destructor
public:
DERIVED& instance() //Never return pointers!!! Be aware of "delete Foo.instance()"
{
if(!_instance)
{
_instance = new DERIVED;
std::atexit( _singleton_deleter ); //Destruction of instance registered at runtime exit (No leak).
}
return static_cast<DERIVED&>( _instance );
}
};
template<typename DERIVED>
DERIVED* generic_singleton<DERIVED>::_instance = nullptr;
The memory release is provided by registering a function that does the delete at the end of the application, with std::ateexit().
What's the point of having a pointer an not just a static variable?
class Singleton
{
public:
static Singleton& instance()
{ static Singleton z; return z; }
private:
Singleton() {}
~SIngleton() {}
};
In don't see any value in deriving it.
If you want to make this pattern coded as a template you can do
template<class S>
S& instance_of() { static S z; return z; }
and make instance_of<yourclass>() a friend of yourclass, having private ctor / dtor.
The use of a static variable makes the object granted to be properly constructed and destructed. (Unlike a remaining leaked pointer, with no destructor call...)
If you have to make a singleton (which you should avoid) the instance and(!) the declaration are a singleton. You could use a template have a 'generic' one, but inheritance is no good.
This is expected behaviour. The rule is you can only access protected members in Deringlton if the pointer is of type Deringlton. You cannot access protected members through a pointer of type Singleton. For example:
Deringlton* d = this;
d->someProtectedMethod(); // OK!
Singleton* s = this;
s->someProtectedMethod(); // Will fail
Since accessing new Singleton is not through a Deringlton pointer, it is not allowed. You can only access it through Deringlton by doing new Deringlton.
This behavior is specified in the standard.
Section 11.4 [class.protected] of C++11 states (emphasis mine):
As described earlier, access to a protected member is granted because
the reference occurs in a friend or member of some class C. If the
access is to form a pointer to member (5.3.1), the
nested-name-specifier shall denote C or a class derived from C. All
other accesses involve a (possibly implicit) object expression
(5.2.5). In this case, the class of the object expression shall be C
or a class derived from C.
What this means is that access to the base constructor is granted only if you are creating an object of the derived class. So for example, this would compile:
Deringlton()
{
Deringlton* p = new Deringlton();
}
Related
All,
I am using C++14 and am making a more-or-less standard Singleton. I am using the latest Visual Studio 2017. This code works:
#include <memory>
class A
{
public:
static A& getInstance()
{
if (instance == nullptr)
instance = std::unique_ptr<A>(new A());
return *instance;
}
private:
A() {}
static std::unique_ptr<A> instance;
};
std::unique_ptr<A> A::instance = nullptr;
However, when I change the creation of the singleton instance to this:
instance = std::make_unique<A>();
I get a compilation error that I am trying to access a private member:
Error C2248 'A::A': cannot access private member declared in class 'A'
c:\program files (x86)\microsoft visual studio\2017\professional\vc\tools\msvc\14.14.26428\include\memory 2510
This feels like a bug to me, as the two forms should be identical in function? Thoughts?
The purpose of std::unique_ptr<> is to control the lifetime of the object pointed to. You may pass a std::unique_ptr<> around, but that will also transfer ownership of the object pointed to. This concept does not match very well with the concept of a singleton. There is only one place that is ever allowed to create (or delete) the singleton. You don't really need a std::unique_ptr<>for that. As already said in the comments, there are simpler ways for that. I would prefer #Praetorian's suggestion:
static A& getInstance()
{
static A instance;
return instance;
}
The reason why you can't use std::make_unique<>() to instantiate your class is that the constructor is private. To access it, you need the accessing function to be a friend. Have a look at How to make std::make_unique a friend of my class for that. Another solution is to provide a public constructor requiring a private type as argument, as described int this solution.
instance = std::make_unique<A>();
this creates the A within the function make_unique. But the ctor you want to call is private.
private:
struct ctor_permission_t{
explicit ctor_permission_t(int){};
};
public:
explicit A(ctor_permission_t):A(){}
};
then
instance = std::make_unique<A>(ctor_permission_t{0});
The ctor_permission_t acts as a token giving its possessor the right to construct an A. We pass this to make_unique.
The explicit int ctor in ctor_permission_t makes it impossible to create it without naming the type, and only within instances and friends of A can name it because it is private. This makes it difficult to bypass this permission token.
To sum up the others answers' and fix some flaws in them:
You can make a private structure with a private constructor which is a friend with your class. Then make your class constructor public but with an additional argument of that private structure.
Also its better to use static function witch return a reference instead of the bare static variable.
#include <memory>
class A
{
struct Private
{
friend A;
private:
explicit Private() = default;
};
public:
static A * getInstance()
{
if (!instance())
instance() = std::make_unique<A>(Private());
return instance();
}
A(Private) {};
private:
static std::unique_ptr<A> & instance()
{
static std::unique_ptr<A> inst;
return inst;
}
};
Or if you really dont need any special configurations which requires using a pointer and heap allocation (like initializing the instance in a special thread or ...) :
class A
{
public:
static A & getInstance()
{
static A instance;
return instance;
}
private:
A() = default;
};
I am new to C++ and recently I have a problem of calling an overriden function from a singleton, the example code is:
class ParentClass
{
public:
ParentClass(){};
~ParentClass(){};
private:
static ParentClass * mInstance;
virtual methodA()
{
//...
}
};
ParentClass * ParentClass::mInstance = new ParentClass;
class ChildClass : public ParentClass
{
private:
virtual methodA() override
{
//....
};
}
Is there anyway to call the overriden methodA for the mInstance?
Change from ParentClass * ParentClass::mInstance = new ParentClass; to ParentClass * ParentClass::mInstance = new ChildClass; You need to instantiate the child class that overrides the function.
Otherwise, no, with the given mInstance (as instance of ParentClass) there is no way of calling the overriden function
Make this following change:
ParentClass * ParentClass::mInstance = new ChildClass;
Otherwise you will not be able to call overriden methodA.
No. You can't polymorphically call an overriden function that is marked private in the base class. A private function can only be called by the owning class itself. If you want a class' function to be exclusively visible to its derived children, then mark it as protected.
And your class ParentClass is not a singleton. A singleton class can't have a public constructor as there must only be one static instance. Ever.
It would also seem meaningless to inherit from a singleton class as the derived class, like its base, can never be constructed during runtime (unless the base's ctor is protected, but then it is starting to smell). All it can do is to access static members of the base or itself.
Anyway, the idiomatic C++-singleton class looks like this:
class singleton {
public:
singleton(const singleton&) = delete;
singleton& operator=(const singleton&) = delete;
static singleton& get_instance() {
static singleton instance;
return instance;
}
private:
singleton() {}
};
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.
I have a program where I need to make a base class which is shared between a dll and some application code. Then I have two different derived classes, one in the dll one in the main application. Each of these have some static member functions which operate on the data in the nase class. (They need to be static as are used as function pointers elsewhere). In its simplest form my issue is shown below.
class Base {
protected:
int var ;
};
class Derived : public Base {
static bool Process( Base *pBase ) {
pBase->var = 2;
return true;
}
};
My compiler complains that I cannot access protected members of pBase even though Derived has protected access to Base. Is there any way around this or am I misunderstanding something?
I can make the Base variables public but this would be bad as in my real instance these are a lump of allocated memory and the semaphores to protect it for multithreading.
Help?
In general (regardless of whether the function is static or not), a
member function of the derived class can only access protected base
class members of objects of its type. It cannot access protected
members of the base if the static type is not that of the derived class
(or a class derived from it). So:
class Base {
protected:
int var;
} ;
class Derived : public Base {
static void f1( Derived* pDerived )
{
pDerived->var = 2; // legal, access through Derived...
}
static bool Process( Base *pBase )
{
pBase->var = 2 ; // illegal, access not through Derived...
}
} ;
Access specifier applies to the Derived class handle (reference/pointer/object) and not the methods of Derived class itself. Even if the method was not static, you would have ended up with the same error. Because you are not accessing var with the derived handle. Demo.
The correct way is to provide a setter method:
class Base {
protected:
int var ;
public:
void setVar(const int v) { var = v; } // <--- add this method
};
Note: There is one more way out, but I am not sure if it's elegant.
(static_cast<Derived*>(pBase))->var = 2;
Is it compulsory to have a private destructor for a singleton class.
If the singleton is implemented as a variable at global scope, it must have a public destructor. Only public members are accessible at global scope.
If it's declared as a static member or static local within its own class, then the destructor may be private. The destructor is called from within class scope, where it is accessible, when the program exits. That is one way to enforce the object being a singleton. Do you need to strongly enforce that? If so, yes. It depends what you mean by "compulsory."
class A{
private:
~A() {}
public:
static A &getGlobalA() {
static A a2; // <- or here - better technique
return a2; // this is initialized upon 1st access
}; // and destroyed on program exit
static A a; // <- constructor, destructor accessed from here
};
A A::a; // <- but "called" from here in terms of control flow
This might not be what you are looking for.. But for reference, I use it as follows:
// .h
class Foo {
public:
static Foo* getInstance();
static void destroy();
private:
Foo();
~Foo();
static Foo* myInstance;
};
// .cpp
Foo* Foo::myInstance = NULL;
Foo* Foo::getInstance(){
if (!myInstance){
myInstance = new Foo();
}
return myInstance;
}
void Foo::destroy(){
delete myInstance;
myInstance = NULL;
}
Then at the end of my program, I call destroy on the object. As Péter points out the system will reclaim the memory when your program ends, so there is no real reason. The reason I use a destroy is when Ogre complained that I hadn't released all the memory I allocated. After that I just use it as "good manner", since I like cleaning up after myself.
In my opinion, the destructor of a signleton should be private. Otherwise somewone is able to call 'delete' for your singleton instance. I know, normally nobody will do it. But if we talk about excellence design, it must be resistant to all possible intended or unitnended damages.
With the modern C++ it is allowed to declare even private destructors for statically constructed objects.
Here is my code snippet for Singleton:
class Singleton
{
public:
static Singleton& GetInstance();
// Before C++ 11
private:
Singleton() {}
~Singleton() {}
Singleton(const Singleton&); // Without implementation
Singleton& operator=(const Singleton&); // Without implementation
// Since C++ 11
private:
Singleton() = default;
~Singleton() = default;
public:
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
};
Singleton& Singleton::GetInstance()
{
static Singleton instance;
return instance;
}
All classes have a destructor. If you don't create one the compiler will do so for you. So your question can be reworded to: Does the destructor for a singleton class have to private?
The simple answer is no, it doesn't have to be.
A more interesting question: Is it a good idea to make the destructor of a singleton class private?
Yes, in general, it is a good idea. If you make it private then your client code won't call the destructor by accident. Calling the destructor would cause the singleton to fail for all clients as the instance would become invalid.
No, and in general objects in C++ are not given private destructors. Keep in mind that Singleton means that there is only one instance, and so it is construction, not destruction, that needs to be controlled / prevented. Usually a singleton has a private constructor, a public destructor, a private static instance variable, and a public static singleton get / lazy construction function, although there are variations on that pattern.
You may return reference to your singleton instance.
class Factory : public IFactory
{
private:
/**
* This class should not be instantiated through its constructor. Since, it implements
* Singleton pattern.
*/
Factory();
public:
virtual ~Factory();
/**
* Accessor method for singleton instance.
* \note use this static method to access to operations of this class.
*/
static IFactory& instance(){
if(!m_instance.get()){
m_instance.reset(new Factory());
}
return static_cast<IFactory&>(*m_instance);
}
/**
* \see IFactory::create
*/
virtual boost::shared_ptr<IConnector> create();
private:
/* Singleton instance */
static boost::scoped_ptr<Factory> m_instance;
};
Having a private destructor as part of a singleton is not required from a programmer's point of view, but essential from a design point of view.
It avoids misuse of the class.
However, if you add a private destructor, you have to instantiate your class:
In a function / method: because if you create it as a global variable, you lose the interest of using a singleton (created to avoid global variables).
With the correct way to instantiate it: if your destructor is private, your class could not be deleted at the end of your program if you instantiate it as a "classic" local variable, because it can't access to it. So you have to instantiate it like this :
Singleton * potatoe = &Singleton::getInstance();
Here, we create a weak pointer named "potatoe", wich correspond to the address of the result of the "getInstance" function.
The consequence is that the destructor will not be called at the end of the function. But because (in "getInstance") the variable is declared "static" in a "static" method, the destructor will be called at the end of the program, without you having to do it.
Here is my code. Feel free to comment it.
// "class.hpp" file
class Singleton {
public:
static Singleton& getInstance() {
static Singleton S;
return S;
}
private:
Singleton();
~Singleton();
};
// "main.cpp" file
#include "class.hpp"
int main()
{
Singleton * patatoe = &Singleton::getInstance();
Singleton * tomatoe = &Singleton::getInstance();
Singleton * salad = &Singleton::getInstance();
return 0;
}