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

本文首发于个人博客https://kezunlin.me/post/8932eaec/，欢迎阅读!

singleton class and usage in c++.

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.