请问C++里如何定义一个类实现该类只能被初始化一次？

请问C++里如何定义一个类实现该类只能被初始化一次？
例如:

//SingleTon.h
class SingleTon
{
  public :
    //
};

//MyClass.cpp
#include <iostream>
#include "SingeleTon.h"
using namespace std;
int main()
{
  SingleTon S;
  //对S对象进行初始化，只能初始化一次？
}

感觉这个问题无法下手。还有就是这个问题根源是想说明什么呢？

21 个解决方案

#1

google singleton模式

#2

单件模型

#3

class Singleton
{
public:
 static Singleton* newInstance();
private:
 Singleton(){}
 ~Singleton(){}
static Singleton* pSingleton;

}
Singleton* Singleton::pSingleton = NULL;
Singleton* Singleton::newInstance()
{  
  if(pSingleton == NULL)
    pSingleton = new Singelton;

  return pSingleton;
}
单件模式，一般与Factory\Builder。。。模式一起使用。。

#4

单件模式
参考代码：

#include <iostream>
class TheOnlyInstance
{
	public:
	static TheOnlyInstance* GetTheOnlyInstance();
	// other methods

	protected:
    TheOnlyInstance(){ }

    private:
    // private data
};
int main()
{
    //TheOnlyInstance noCanDo;
    TheOnlyInstance* noCanDo1 = TheOnlyInstance::GetTheOnlyInstance();
    TheOnlyInstance* noCanDo2 = TheOnlyInstance::GetTheOnlyInstance();
// 由于静态变量在函数调用结束后仍保存在内存中，所以以后再调用GetTheOnlyInstance时，将返回同一个静态对象的地址！
    std::cout << noCanDo1 << '\t' << noCanDo2 << '\n';
    system("pause");
}
TheOnlyInstance* TheOnlyInstance::GetTheOnlyInstance()
{
    static TheOnlyInstance obj;
    std::cout << " Constructer is called!" << std::endl;
    return &obj;
}

#5

单件模式

#6

我觉得大家误解了楼主的意思，“只能初始化一次”而不是“只能生成一个对象”，单件模式指的是后者。楼主不知道我说的对不对？如果是我说的这种情况的话可以用一个成员变量来标志有没有被初始化，根据该变量的值来决定要不要做初始化。

#7

初始化一次...?难道构造函数还能多次被调用吗？显示调用除外...

#8

“类被初始化一次”是什么意思？
是说实例化一次吗？如果是的话，应该就是SingleTon的用法。

#9

所有构造函数统统变成私有
然后类中包含自己类型的STATIC对象

#10

类里定义一个静态的整型变量用来表示类的对象的个数，在构造函数中就可以根据这个变量进行控制了

#11

引用 6 楼 Mougou 的回复:

我觉得大家误解了楼主的意思，“只能初始化一次”而不是“只能生成一个对象”，单件模式指的是后者。楼主不知道我说的对不对？如果是我说的这种情况的话可以用一个成员变量来标志有没有被初始化，根据该变量的值来决定要不要做初始化。

我觉得LZ是6楼的想法

#12

构造函数私有化。
提供类级别的构造函数。
缺点：只能动态生成对象。

#13

按照lz的原文意思，就是要实现Singleton模式

引用 11 楼 tncqsy 的回复:

引用 6 楼 Mougou 的回复:
我觉得大家误解了楼主的意思，“只能初始化一次”而不是“只能生成一个对象”，单件模式指的是后者。楼主不知道我说的对不对？如果是我说的这种情况的话可以用一个成员变量来标志有没有被初始化，根据该变量的值来决定要不要做初始化。 
 
我觉得LZ是6楼的想法

#14

从楼主的代码看出来应该就是单件模式

#15

Up 学习

#16

引用 6 楼 Mougou 的回复:

我觉得大家误解了楼主的意思，“只能初始化一次”而不是“只能生成一个对象”，单件模式指的是后者。楼主不知道我说的对不对？如果是我说的这种情况的话可以用一个成员变量来标志有没有被初始化，根据该变量的值来决定要不要做初始化。

不好意昨天晚上临熄灯把帖子发了上来，我的问题用楼上很多人的说法就是要实现“单件模式”：实现要求一个类只能被实例化一次。
至于我发题时所说“只能初始化一次”是没有能把题意表达明白。不好意思！

#17

不知道lz什么意思

#18

谢谢3楼和4楼，4楼的注释很清晰！
现在我把我的完整代码写在这里，晚上回来结帐。

//CSingleTon.h 类定义头文件
#pragma once

class CSingleTon
{
public:
	static CSingleTon* GetSingleTon();  //定义静态成员函数
private:
	CSingleTon(){}
	~CSingleTon(){}
	static CSingleTon* pSingleTon;      //定义静态成员指针变量，我认为这里很巧妙
};

//SingleTon.cpp 类实现CPP文件
#include "SingleTon.h"
#include <iostream>
using namespace std;
#define NULL 0 

CSingleTon* CSingleTon::pSingleTon = NULL;   //将静态指针变量初始化为NULL，为下面作标志准备

CSingleTon* CSingleTon::GetSingleTon()
{
	if (pSingleTon == NULL)  
	{
                //执行完下面这句静态变量pSingleTon将会得到一个固定的地址，不再为NULL，是关键。实现了类的例化。
		pSingleTon = new CSingleTon;  		
                cout << "Constructed!" << endl;   //此句只会在第一次类实例化时被调用
		return pSingleTon;
	}
}

//MyClass.cpp  主函数实现文件
#include <iostream>
#include "SingleTon.h"
using namespace std;

int main()
{
	CSingleTon* c1 = CSingleTon::GetSingleTon(); //只有这句会输出
	CSingleTon* c2 = CSingleTon::GetSingleTon();
	CSingleTon* c3 = CSingleTon::GetSingleTon();
	CSingleTon* c4 = CSingleTon::GetSingleTon();

	return 0;
}

这样设计代码不知道在什么时候会用到。还有3楼所说的Factory\Builder都不明白。
还是得学习，差的太多喽！

#19

个你一个最简单的实现方法

class Singleton
{
protected:
Singleton(){}

public:
Singleton* GetInstance()
{
static Singleton instance;
return instance;
}
};

#20

你一个最简单的实现方法

class Singleton
{
protected:
Singleton(){}

public:
static Singleton* GetInstance()
{
static Singleton instance;
return &instance;
}
};

====================NB的分割线==================================
调用方法
Singleton* pInstance = Singleton::GetInstance();

#21

class SingleTon
{
private:
	static bool bInit;
	void Init()
	{
		//DoSomething
	}
public:
	SingleTon()
	{
		if (!bInit)
		{
			bInit = !bInit;
			Init();
		}
		//Do Other thing
	}
};

bool SingleTon::bInit = false;