【C++】特殊类设计

目录

设计一个类不能被拷贝

设计一个类，只能在堆上创建对象

设计一个类，只能在栈上创建对象

设计一个类，不能被继承

设计一个类，只能创建一个对象（单例模式）

---

设计一个类不能被拷贝

C++98的做法：将拷贝构造和赋值重载只声明不实现，并设为私有，为什么要声明，因为它们是默认成员函数，我们不写编译器会自动生成

C++11做法：直接用delete

---

设计一个类，只能在堆上创建对象

方法一：析构函数私有

这时候就无法直接创建对象，但是可以new对象，因为析构函数私有，这时创建对象没办法自动调用析构，怎么释放呢，许愿写一个公有的释放函数通过new返回的指针去调用释放函数

class HeapOnly
{
private:
	~HeapOnly()
	{
		cout << "~" << endl;
	}
};

int main()
{
	HeapOnly ho; //无法自动调用析构
	HeapOnly* ptr = new HeapOnly;
	delete ptr; //无法调用析构

	return 0;
}

静态公有释放函数

class HeapOnly
{
public:
	static void Destroy(HeapOnly* ptr)
	{
		delete ptr;
	}

private:
	~HeapOnly()
	{
		cout << "~" << endl;
	}
};

int main()
{
	//HeapOnly ho; //无法自动调用析构
	HeapOnly* ptr = new HeapOnly;
	//delete ptr; //无法调用析构
	HeapOnly::Destroy(ptr);
	return 0;
}

更好的写法，直接delete this

class HeapOnly
{
public:
	void Destroy()
	{
		delete this;
	}

private:
	~HeapOnly()
	{
		cout << "~" << endl;
	}
};

int main()
{
	HeapOnly* ptr = new HeapOnly;
	ptr->Destroy();
	return 0;
}

方法二：构造函数私有

这时无论是直接创建对象还是new对象都不行了，

class HeapOnly
{
public:


private:
	HeapOnly()
	{
		cout << "~" << endl;
	}
};

int main()
{
	HeapOnly h1;
	HeapOnly* ptr = new HeapOnly;

	return 0;
}

需要写一个公有函数来创建

但是这里却无法调用Creat()，因为这里调用这个函数得先有对象，但是我调用这个函数的原因就是我要创建对象，这里就可以用静态来解决

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

private:
	HeapOnly()
	{
		cout << "~" << endl;
	}
};

int main()
{
	HeapOnly* ptr = Creat(); //调用不了
	return 0;
}

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

private:
	HeapOnly()
	{
		cout << "~" << endl;
	}
};

int main()
{
	HeapOnly* ptr = HeapOnly::Creat();
	return 0;
}

有一个缺陷就是通过拷贝构造也能在栈上创建，所以要把拷贝构造给禁了

---

设计一个类，只能在栈上创建对象

先把构造函数私有，然后写一个静态的公有创建函数

class StackOnly
{
public:
	static StackOnly Creat()
	{
		StackOnly s1;
		return s1;
	}

private:
	StackOnly()
	{
		cout << "s" << endl;
	}
};

int main()
{
	StackOnly s = StackOnly::Creat();
	return 0;
}

有一个缺陷，就是可以通过拷贝构造创建，这里如果单纯禁掉拷贝构造的话，那个公有函数的传值返回就无法实现，

new分为operator new 和 调用拷贝构造，operator new是全局的，但如果类内写了一个就会调类内的，new这个对象的时候就会调类内的不会调全局的，所以我们可以把operator new禁掉，相当于间接禁掉new

StackOnly* ptr = new StackOnly(s);

设计一个类，不能被继承

C++98做法：构造函数私有，派生类就调不到基类的构造函数则无法继承

C++11做法：final表示该类不能被继承

设计一个类，只能创建一个对象（单例模式）

单例模式是一种设计模式，设计模式是代码设计的经验总结

单例是指全局只有一个唯一的实例对象，单例模式分为饿汉模式和懒汉模式，饿汉：提前创建好，main函数启动时创建好实例对象，懒汉：第一次用的时候再创建

饿汉

先把构造函数和拷贝构造私有，创建一个A类型的静态成员，因为静态成员不在对象里面，是存在静态区的，类内声明类外定义，然后提供一个该成员地址的静态公有函数，通过这个函数获取到这一个唯一对象的地址。

class A
{
public:
	static A* GetInstance()
	{
		return &_inst;
	}

	void print()
	{

	}

private:
	A()
	{}
	A(const A& aa) = delete;
	A& operator=(const A& aa) = delete;

	static A _inst;
};

A A::_inst;

int main()
{
	A::GetInstance()->print();
	return 0;
}

饿汉模式的优点：相比懒汉实现简单，缺点：1. 可能会导致进程启动慢，2. 无法控制单例先后启动顺序

懒汉

在饿汉的基础上把静态成员的类型变成指针，在类外定义为空，

获取对象的函数也需要修改

	static B* GetInstance()
	{
		if (_Binst == nullptr)
		{
			_Binst = new B;
		}
		return _Binst;
	}

int main()
{
	B::GetInstance()->print();
	return 0;
}

析构问题

new的懒汉对象一般不需要释放，进程正常结束会释放，但有时候我们需要在析构做点事情比如持久化处理，想要让进程结束时调用析构，首先弄一个gc内部类，创建一个gc静态对象，在main函数结束它会调用析构函数，

class B
{
public:
	static B* GetInstance()
	{
		if (_Binst == nullptr)
		{
			_Binst = new B;
		}
		return _Binst;
	}

	void print()
	{

	}

	static void DelInstance()
	{
		if (_Binst)
		{
			delete _Binst;
			_Binst = nullptr;
		}
	}

private:
	B()
	{}
	~B()
	{
		cout << "hhh" << endl;
	}
	B(const B& aa) = delete;
	B& operator=(const B& aa) = delete;

	static B* _Binst;

	class gc
	{
	public:
		~gc()
		{
			DelInstance();
		}
	};

	static gc _gc;
};

B* B::_Binst = nullptr;
B::gc B::_gc;