// GoldConfig.h: 此文件包含 "GoldConfig" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#pragma once
#ifndef GOLDCONFIG_H
#define GOLDCONFIG_H
#include <iostream>
#include <list>
#include <map>
using namespace std;
namespace DuLazySingletonPattern
{
/// <summary>
/// 懒汉式
/// Lazy Singleton
/// </summary>
class GoldConfig
{
private:
GoldConfig() {};
GoldConfig(const GoldConfig& tmpobj);
GoldConfig& operator = (const GoldConfig& tmpobj);
~GoldConfig() {};
public:
/// <summary>
///
/// </summary>
/// <returns></returns>
static GoldConfig* getInstance()
{
//std::lock_guard<std::mutex> gcguard(my_mutex);
if (m_instance == nullptr)
{
//这里再加锁
//std::lock_guard<std::mutex> gcguard(my_mutex);
//if (m_instance == nullptr)
//{
m_instance = new GoldConfig();
static Garbo garboobj;
cout << "getInstance: no data." << m_instance << endl;
//}
}
else
{
cout << "ok, is data" << endl;
}
return m_instance;
}
public:
/// <summary>
/// 要手工调用才能释放内存
/// </summary>
static void freeInstance()
{
if (m_instance != nullptr)
{
delete GoldConfig::m_instance;
GoldConfig::m_instance = nullptr;
cout << "Sinleton: is data" << m_instance << endl;
}
}
private:
/// <summary>
/// 手工释放单件类对象引入的GameConfig类中的嵌套类（垃圾回收）
/// </summary>
class Garbo
{
public:
~Garbo()
{
if (GoldConfig::m_instance != nullptr)
{
delete GoldConfig::m_instance;
GoldConfig::m_instance = nullptr;
cout << "du,getInstance:" << m_instance << endl;
}
}
};
private:
static GoldConfig* m_instance; //指向本类对象的指针
};
}
#endif
// GoldConfig.cpp: 此文件包含 "GoldConfig" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#include "GoldConfig.h"
using namespace std;
namespace DuLazySingletonPattern
{
GoldConfig* GoldConfig::m_instance = nullptr; //在类外，某个.cpp源文件的开头位置，为静态成员变量赋值（定义并赋值）
}
// GoldCommon.h: 此文件包含 "GoldCommon" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#pragma once
#ifndef GOLDCOMMON_H
#define GOLDCOMMON_H
#include <iostream>
#include <list>
#include <map>
#include <atomic> //#include的头文件加在源文件顶部位置
#include <mutex>
using namespace std;
namespace DuCommonSingletonPattern
{
/// <summary>
/// 常用式
/// </summary>
class GoldCommon
{
private:
GoldCommon() {};
GoldCommon(const GoldCommon& tmpobj);
GoldCommon& operator = (const GoldCommon& tmpobj);
~GoldCommon() {};
public:
static GoldCommon* getInstance()
{
GoldCommon* tmp = m_instance.load(std::memory_order_relaxed);
std::atomic_thread_fence(std::memory_order_acquire);
if (tmp == nullptr)
{
std::lock_guard<std::mutex> lock(m_mutex);
tmp = m_instance.load(std::memory_order_relaxed);
if (tmp == nullptr)
{
tmp = new GoldCommon();
static Garbo garboobj;
std::atomic_thread_fence(std::memory_order_release);
m_instance.store(tmp, std::memory_order_relaxed);
}
}
cout << "常用式" << endl;
return tmp;
}
private:
//手工释放单件类对象引入的GameConfig类中的嵌套类（垃圾回收）
class Garbo
{
public:
~Garbo()
{
if (GoldCommon::m_instance != nullptr)
{
delete GoldCommon::m_instance;
GoldCommon::m_instance = nullptr;
}
}
};
private:
static atomic<GoldCommon*> m_instance;
static std::mutex m_mutex;
};
}
#endif
// GoldCommon.cpp: 此文件包含 "GoldCommon" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#include "GoldCommon.h"
#include <atomic> //#include的头文件加在源文件顶部位置
#include <mutex>
using namespace std;
namespace DuCommonSingletonPattern
{
std::atomic<GoldCommon*> GoldCommon::m_instance;
std::mutex GoldCommon::m_mutex;
}
// GoldEager.h: 此文件包含 "GoldEager" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#pragma once
#ifndef GOLDEAGER_H
#define GOLDEAGER_H
#include <iostream>
#include <list>
#include <map>
#include <atomic> //#include的头文件加在源文件顶部位置
#include <mutex>
using namespace std;
namespace DuEagerSingletonPattern
{
/// <summary>
/// 饿汉式 Eager Singleton
/// </summary>
class GoldEager
{
//......
private:
GoldEager() {};
GoldEager(const GoldEager& tmpobj);
GoldEager& operator = (const GoldEager& tmpobj);
~GoldEager() {};
public:
static GoldEager* getInstance()
{
cout << "Eager Singleton" << endl;
return m_instance;
}
private:
static GoldEager* m_instance; //指向本类对象的指针
private:
//手工释放单件类对象引入的GoldEager类中的嵌套类（垃圾回收）
class Garbo
{
public:
~Garbo()
{
if (GoldEager::m_instance != nullptr)
{
delete GoldEager::m_instance;
GoldEager::m_instance = nullptr;
}
}
};
private:
static Garbo garboobj;
};
}
#endif
// GoldEager.cpp: 此文件包含 "GoldEager" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#include "GoldEager.h"
#include <atomic> //#include的头文件加在源文件顶部位置
#include <mutex>
using namespace std;
namespace DuEagerSingletonPattern
{
GoldEager* GoldEager::m_instance = new GoldEager();//趁静态成员变量定义的时机直接初始化是被允许的，即便GameConfig构造函数用private修饰
GoldEager::Garbo GoldEager::garboobj;
}
// GoldFunction.h: 此文件包含 "GoldFunction" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#pragma once
#ifndef GOLDFUNCTION_H
#define GOLDFUNCTION_H
#include <iostream>
#include <list>
#include <map>
#include <atomic> //#include的头文件加在源文件顶部位置
#include <mutex>
using namespace std;
namespace DuFunctionSingletonPattern
{
/// <summary>
///
/// </summary>
class GoldFunction
{
private:
GoldFunction() {};
GoldFunction(const GoldFunction& tmpobj);
GoldFunction& operator = (const GoldFunction& tmpobj);
~GoldFunction() {};
public:
static GoldFunction& getInstance()
{
static GoldFunction instance;
cout << "GoldFunction" << endl;
return instance;
}
public:
//int myfunc();
};
}
#endif
// GoldFunction.cpp: 此文件包含 "GoldFunction" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#include "GoldFunction.h"
using namespace std;
namespace DuFunctionSingletonPattern
{
/// <summary>
///
/// </summary>
/// <returns></returns>
int myfunc()
{
static int stcs = 100; //不需要调用myfunc函数，stcs就已经等于100了
stcs += 180;
return stcs;
}
}
// GeovinDu.h: 此文件包含 "GeovinDu" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#pragma once
#ifndef GEOVINDU_H
#define GEOVINDU_H
#include <iostream>
#include <list>
#include <map>
using namespace std;
namespace DuSingletonPattern
{
/// <summary>
///
/// </summary>
class GeovinDu
{
private:
public:
/// <summary>
/// 懒汉式
/// </summary>
void diplayLazy();
/// <summary>
/// 常用式
/// </summary>
void displayCommon();
/// <summary>
/// 饿汉式
/// </summary>
void displayEager();
/// <summary>
///
/// </summary>
void displaFunction();
};
}
#endif
// GeovinDu.h: 此文件包含 "GeovinDu" 类。装饰器模式 Singleton Pattern C++ 14
// //Singleton Pattern 单例模式 单件模式、Singleton
// 2023年5月20日 涂聚文 Geovin Du Visual Studio 2022 edit.
#include "GeovinDu.h"
#include <iostream>
#include <list>
#include <map>
#include "GoldConfig.h";
#include "GoldCommon.h"
#include "GoldEager.h"
#include "GoldFunction.h"
using namespace std;
using namespace DuLazySingletonPattern;
using namespace DuCommonSingletonPattern;
using namespace DuEagerSingletonPattern;
using namespace DuFunctionSingletonPattern;
namespace DuSingletonPattern
{
/// <summary>
/// 懒汉式
/// </summary>
void GeovinDu::diplayLazy()
{
/*DuLazySingletonPattern::GameConfig g_config1;
DuLazySingletonPattern::GameConfig g_config2;*/
GoldConfig* g_gc = GoldConfig::getInstance();
GoldConfig* g_gc2 = GoldConfig::getInstance();
g_gc->getInstance();
g_gc2->freeInstance(); //手工释放内存演示
}
/// <summary>
/// 常用式
/// </summary>
void GeovinDu::displayCommon()
{
DuCommonSingletonPattern::GoldCommon* g_gc_2 = DuCommonSingletonPattern::GoldCommon::getInstance();
DuCommonSingletonPattern::GoldCommon* g_gc2_2 = DuCommonSingletonPattern::GoldCommon::getInstance();
}
/// <summary>
/// 饿汉式
/// </summary>
void GeovinDu::displayEager()
{
DuEagerSingletonPattern::GoldEager* g_gc_2 = DuEagerSingletonPattern::GoldEager::getInstance();
DuEagerSingletonPattern::GoldEager* g_gc2_2 = DuEagerSingletonPattern::GoldEager::getInstance();
}
/// <summary>
///
/// </summary>
void GeovinDu::displaFunction()
{
DuFunctionSingletonPattern::GoldFunction& g_gc40 = DuFunctionSingletonPattern::GoldFunction::getInstance();
//DuFunctionSingletonPattern::myfunc();
}
}
调用：
// ConsoleDuSingletonPattern.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
// Singleton Pattern 单例模式 单件模式、Singleton C++ 14
// 2023年4月30日 涂聚文 Geovin Du Visual Studio 2022 edit. 文章来源《C++新经典设计模式》 王健伟编著 清华大学出版社
#define _UNICODE
#include <iostream>
#include "GeovinDu.h"
using namespace std;
using namespace DuSingletonPattern;
int main()
{
std::cout << "Hello World! 涂聚文 Geovin Du\n";
GeovinDu geovin;
geovin.diplayLazy();
geovin.displayCommon();
geovin.displayEager();
geovin.displaFunction();
system("pause");
return 0;
}
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单
// 入门使用技巧:
// 1. 使用解决方案资源管理器窗口添加/管理文件
// 2. 使用团队资源管理器窗口连接到源代码管理
// 3. 使用输出窗口查看生成输出和其他消息
// 4. 使用错误列表窗口查看错误
// 5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
// 6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
#define UNICODE
输出：
Hello World! 涂聚文 Geovin Du getInstance: no data.000001550C81A8A0 ok, is data ok, is data Sinleton: is data0000000000000000 常用式 常用式 Eager Singleton Eager Singleton GoldFunction 请按任意键继续. . .
标签：std,Singleton,Pattern,GoldConfig,namespace,GoldEager,cpp,include From： https://www.cnblogs.com/geovindu/p/17416814.html