Instantly share code, notes, and snippets.

Embed
What would you like to do?
Singleton example in C++
/*
* Example of a singleton design pattern.
* Copyright (C) 2011 Radek Pazdera
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iostream>
class Singleton
{
private:
/* Here will be the instance stored. */
static Singleton* instance;
/* Private constructor to prevent instancing. */
Singleton();
public:
/* Static access method. */
static Singleton* getInstance();
};
/* Null, because instance will be initialized on demand. */
Singleton* Singleton::instance = 0;
Singleton* Singleton::getInstance()
{
if (instance == 0)
{
instance = new Singleton();
}
return instance;
}
Singleton::Singleton()
{}
int main()
{
//new Singleton(); // Won't work
Singleton* s = Singleton::getInstance(); // Ok
Singleton* r = Singleton::getInstance();
/* The addresses will be the same. */
std::cout << s << std::endl;
std::cout << r << std::endl;
}
@yeweishuai

This comment has been minimized.

Show comment
Hide comment
@yeweishuai

yeweishuai May 4, 2017

If this is a header .h file, class implements should be written in .cpp file
Otherwise, compile error occurs.

yeweishuai commented May 4, 2017

If this is a header .h file, class implements should be written in .cpp file
Otherwise, compile error occurs.

@CMLDMR

This comment has been minimized.

Show comment
Hide comment
@CMLDMR

CMLDMR Oct 4, 2017

Good Example to show singleton. Thank you.

CMLDMR commented Oct 4, 2017

Good Example to show singleton. Thank you.

@oliviazqq

This comment has been minimized.

Show comment
Hide comment
@oliviazqq

oliviazqq Nov 22, 2017

thank you,very good

oliviazqq commented Nov 22, 2017

thank you,very good

@Rushi-Kumar

This comment has been minimized.

Show comment
Hide comment
@Rushi-Kumar

Rushi-Kumar Dec 1, 2017

how to implement in header only library.

Rushi-Kumar commented Dec 1, 2017

how to implement in header only library.

@zhangxiao-ustc

This comment has been minimized.

Show comment
Hide comment
@zhangxiao-ustc

zhangxiao-ustc Jan 23, 2018

Is this implementation thread-safe?

zhangxiao-ustc commented Jan 23, 2018

Is this implementation thread-safe?

@BugLight

This comment has been minimized.

Show comment
Hide comment
@BugLight

BugLight Feb 11, 2018

Your implementation has a memory leak.

BugLight commented Feb 11, 2018

Your implementation has a memory leak.

@luca1337

This comment has been minimized.

Show comment
Hide comment
@luca1337

luca1337 Mar 10, 2018

nice example!

luca1337 commented Mar 10, 2018

nice example!

@xintongc

This comment has been minimized.

Show comment
Hide comment
@xintongc

xintongc Mar 11, 2018

Very helpful! Thanks a lot!

xintongc commented Mar 11, 2018

Very helpful! Thanks a lot!

@ZOulhadj

This comment has been minimized.

Show comment
Hide comment
@ZOulhadj

ZOulhadj Mar 11, 2018

Nice, however, I just would say that there is a memory leak. When you create a raw pointer you need to make sure to delete it in the destructor. If not then make sure to new a smart pointer so it gets deleted automatically.

ZOulhadj commented Mar 11, 2018

Nice, however, I just would say that there is a memory leak. When you create a raw pointer you need to make sure to delete it in the destructor. If not then make sure to new a smart pointer so it gets deleted automatically.

@OSinitsyn

This comment has been minimized.

Show comment
Hide comment
@OSinitsyn

OSinitsyn Mar 24, 2018

The copy constructor and the copy assignment operator should be declared private, i.e.

private:
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);

Otherwise, you will be able to clone your object. If you are using C++ 11, you may leave the copy constructor and the copy assignment operator public but explicitly delete them:

public:
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;

OSinitsyn commented Mar 24, 2018

The copy constructor and the copy assignment operator should be declared private, i.e.

private:
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);

Otherwise, you will be able to clone your object. If you are using C++ 11, you may leave the copy constructor and the copy assignment operator public but explicitly delete them:

public:
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;

@ProgrammerXDesigner

This comment has been minimized.

Show comment
Hide comment
@ProgrammerXDesigner

ProgrammerXDesigner May 11, 2018

Nice, but I have some notes here:

  • First, you have memory leak.
  • And second, you should declare the copy constructor and the assignment operator of your class as private or delete them explicitly to prevent cloning your object.

ProgrammerXDesigner commented May 11, 2018

Nice, but I have some notes here:

  • First, you have memory leak.
  • And second, you should declare the copy constructor and the assignment operator of your class as private or delete them explicitly to prevent cloning your object.
@akbarsaleemt

This comment has been minimized.

Show comment
Hide comment
@akbarsaleemt

akbarsaleemt Jul 30, 2018

how can i access same object every time for my program
#include
using namespace std;
class student
{
private:
int id;
int marks;
public:
void adddata()
{
int i,mks;
cout<<"enter student marks and id:";
cin>>i;
cin>>mks;
id=i;
marks=mks;
print();
}
void print()
{
cout<<"student id num:"<<id<<endl;
cout<<"student marks:"<<marks<<endl;
}

};

int main()
{
student s;

s.adddata();

x.adddata();

return 0;

}

akbarsaleemt commented Jul 30, 2018

how can i access same object every time for my program
#include
using namespace std;
class student
{
private:
int id;
int marks;
public:
void adddata()
{
int i,mks;
cout<<"enter student marks and id:";
cin>>i;
cin>>mks;
id=i;
marks=mks;
print();
}
void print()
{
cout<<"student id num:"<<id<<endl;
cout<<"student marks:"<<marks<<endl;
}

};

int main()
{
student s;

s.adddata();

x.adddata();

return 0;

}

@mohamed-karaoui

This comment has been minimized.

Show comment
Hide comment
@mohamed-karaoui

mohamed-karaoui Aug 23, 2018

The use of "static" inside the function getInstance() makes things even cleaner:

 * Example of a singleton design pattern.                                        
 * Copyright (C) 2011 Radek Pazdera                                              
 * This program is free software: you can redistribute it and/or modify          
 * it under the terms of the GNU General Public License as published by          
 * the Free Software Foundation, either version 3 of the License, or             
 * (at your option) any later version.                                           
 * This program is distributed in the hope that it will be useful,               
 * but WITHOUT ANY WARRANTY; without even the implied warranty of                
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  
 * GNU General Public License for more details.                                  
 * You should have received a copy of the GNU General Public License             
 * along with this program. If not, see <http://www.gnu.org/licenses/>.          
 */
#include <iostream>                                                              
                                                                                 
class Singleton                                                                  
{                                                                                
    private:                                                                     
        /* Private constructor to prevent instancing. */                         
        Singleton();                                                             
                                                                                 
    public:                                                                      
        /* Static access method. */                                              
        static Singleton* getInstance();                                         
};                                                                               
                                                                                 
Singleton* Singleton::getInstance()                                              
{                                                                                
    static Singleton instance;                                                   
                                                                                 
    return &instance;                                                            
}                                                                                
                                                                                 
Singleton::Singleton()                                                           
{}                                                                               
                                                                                 
int main()                                                                       
{                                                                                
    //new Singleton(); // Won't work                                             
    Singleton* s = Singleton::getInstance(); // Ok                               
    Singleton* r = Singleton::getInstance();                                     
                                                                                 
    /* The addresses will be the same. */                                        
    std::cout << s << std::endl;                                                 
    std::cout << r << std::endl;                                                 
}

mohamed-karaoui commented Aug 23, 2018

The use of "static" inside the function getInstance() makes things even cleaner:

 * Example of a singleton design pattern.                                        
 * Copyright (C) 2011 Radek Pazdera                                              
 * This program is free software: you can redistribute it and/or modify          
 * it under the terms of the GNU General Public License as published by          
 * the Free Software Foundation, either version 3 of the License, or             
 * (at your option) any later version.                                           
 * This program is distributed in the hope that it will be useful,               
 * but WITHOUT ANY WARRANTY; without even the implied warranty of                
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  
 * GNU General Public License for more details.                                  
 * You should have received a copy of the GNU General Public License             
 * along with this program. If not, see <http://www.gnu.org/licenses/>.          
 */
#include <iostream>                                                              
                                                                                 
class Singleton                                                                  
{                                                                                
    private:                                                                     
        /* Private constructor to prevent instancing. */                         
        Singleton();                                                             
                                                                                 
    public:                                                                      
        /* Static access method. */                                              
        static Singleton* getInstance();                                         
};                                                                               
                                                                                 
Singleton* Singleton::getInstance()                                              
{                                                                                
    static Singleton instance;                                                   
                                                                                 
    return &instance;                                                            
}                                                                                
                                                                                 
Singleton::Singleton()                                                           
{}                                                                               
                                                                                 
int main()                                                                       
{                                                                                
    //new Singleton(); // Won't work                                             
    Singleton* s = Singleton::getInstance(); // Ok                               
    Singleton* r = Singleton::getInstance();                                     
                                                                                 
    /* The addresses will be the same. */                                        
    std::cout << s << std::endl;                                                 
    std::cout << r << std::endl;                                                 
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment