【C++】特殊类的设计

• • 不能被拷贝
  • 不能被继承
  • 只能在堆上创建对象
  • 只能在栈上创建对象

禁用拷贝构造和赋值

• C++98写法

只声明，不定义

把拷贝构造和赋值私有化(只声明不定义的化，可以在类外实现)

• C++11写法

使用delete关键字，禁用拷贝构造和赋值

class CopyBan
{
public:
private:

	//c++98写法，私有化后外界就无法调用
	//CopyBan(const CopyBan&);
	//CopyBan& operator=(const CopyBan&);

	//c++11写法
	CopyBan(const CopyBan&) = delete;
	CopyBan& operator=(const CopyBan&) = delete;
};

• C++98写法

构造函数私有化，子类就无法调用父类的构造函数

class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit()
	{}
};

• C++11

final关键字，final修饰类，表示该类不能被继承

class NonInherit final
{
	//......
};

• 构造函数私有化，禁用拷贝构造和赋值
• 提供一个公有接口，在堆中创建对象，返回对象的指针
• 这个接口需要是静态的，才可以在没有对象的情况下调用这个接口

class HeapOnly {
public:
	static HeapOnly* CreateObject() {
		return new HeapOnly;
	}

private:
	HeapOnly()
	{}

	//防拷贝
	
	//C++98 只声明，不实现
	//HeapOnly(const HeapOnly&);

	//C++11 delete
	HeapOnly(const HeapOnly&) = delete;
};

方法一

• 构造函数私有化
• 提供一个公有接口，在栈上创建对象，返回对象的拷贝

class StackOnly {
public:
	static StackOnly CreateObject() {
		return StackOnly();
	}
private:
	StackOnly(){}
};

方法二

• 屏蔽new

• 屏蔽delete

class StackOnly {
public:
	StackOnly() {}
private:
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
};

这种方法有一个缺陷，他虽然不能在堆上创建对象，但是可以在静态区创建对象，不符合只能在栈上创建对象的条件