Guide

what singleton solve?

https://stackoverflow.com/questions/137975/what-is-so-bad-about-singletons

Singletons solve one (and only one) problem.

Resource Contention.

If you have some resource that

(1) can only have a single instance, and

(2) you need to manage that single instance,

you need a singleton.

There aren't many examples. A log file is the big one. You don't want to just abandon a single log file. You want to flush, sync and close it properly. This is an example of a single shared resource that has to be managed.

It's rare that you need a singleton. The reason they're bad is that they feel like a global and they're a fully paid up member of the GoF Design Patterns book.

When you think you need a global, you're probably making a terrible design mistake.

local static object

https://stackoverflow.com/questions/1008019/c-singleton-design-pattern

Actually, in C++ preferred way is local static object.

singleton pure

class Singleton

{

private:

	Singleton();

public:

	Singleton(Singleton const&) = delete;

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

	static Singleton& instance()

	{

	  static Singleton INSTANCE;

	  return INSTANCE;

	}

};

singleton with shared_ptr

class Singleton

{

private:

   Singleton();

public:

	Singleton(Singleton const&) = delete;

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

	static std::shared_ptr<Singleton> instance()

	{

		static std::shared_ptr<Singleton> s{new Singleton};

		return s;

	}

};

singleton usage

http://www.programlife.net/cpp-singleton-memory-retrieve.html

#define DISALLOW_COPY(TypeName) \

	TypeName(const TypeName&)

#define DISALLOW_ASSIGN(TypeName) \

	TypeName& operator=(const TypeName&)

#define DISALLOW_COPY_AND_ASSIGN(TypeName) \

	TypeName(const TypeName&);               \

	TypeName& operator=(const TypeName&)

class CSingleton

{

public:

	static CSingleton &GetInstance()

	{

		static CSingleton instance;

		return instance;

	}

	void DoSomething()

	{

		printf("void CSingleton::DoSomething() called.\n");

	}

private:

	CSingleton() {};

	DISALLOW_COPY_AND_ASSIGN(CSingleton);

};

// usage

CSingleton::GetInstance().DoSomething();	// OK

CSingleton& singleton = CSingleton::GetInstance(); // OK with reference

singleton.DoSomething();

CSingleton singleton = CSingleton::GetInstance(); // ERROR (copy constructor)

Example

config.h

#pragma once

class Config

{

public:

	static Config& GetInstance(std::string filename="./config.ini");

	~Config();

private:

	Config(std::string filename);

	Config(const Config& ref) {}

	Config& operator =(const Config& ref) { return *this; }

};

config.cpp

#include "Config.h"

/*

static config instance will only be created once by calling Config::Config,

when program exit,static variable will be destoryed by calling Config::~Config.

*/

Config& Config::GetInstance(std::string filename)

{

	static Config instance(filename);

	return instance;

}

Config::Config(std::string filename)

{

	std::cout << "[LOG] Config::Config count= "<<count << std::endl;

	// load config from filename

	// ...

}

Config::~Config()

{

	std::cout << "[LOG] Config::~Config count= " << count << std::endl;

}

mysqldb.cpp

void MysqlDb::load_config(std::string filename)

{

	this->mysql_connection = Config::GetInstance(filename).MYSQL_CONNECTION;

	this->mysql_username = Config::GetInstance(filename).MYSQL_USERNAME;

	this->mysql_password = Config::GetInstance(filename).MYSQL_PASSWORD;

	this->mysql_database = Config::GetInstance(filename).MYSQL_DATABASE;

	this->max_connection_pool_size = Config::GetInstance(filename).MAX_CONNECTION_POOL_SIZE;

}

Reference

[c-singleton-vs-global-static-object](- https://stackoverflow.com/questions/1463707/c-singleton-vs-global-static-object)
c-singleton-design-pattern

-cpp-singleton-memory-retrieve

History

20180122： created.

Copyright

Post author: kezunlin
Post link: https://kezunlin.me/post/8932eaec/
Copyright Notice: All articles in this blog are licensed under CC BY-NC-SA 3.0 unless stating additionally.

巴特西

c++中实现单例模式singleton class