C++特殊类的设计与类型转换

#include<iostream>

using namespace std;
class HeapOnly
{
public:
	static HeapOnly* func()//这里如果不用静态就无法创建对象了，也导致这个函数无法被调用
	{
		return new HeapOnly;
	}
private:
	HeapOnly()//防止随意的创建对象
	{}
	HeapOnly(const HeapOnly& a) = delete;//如果不删除拷贝函数创建的对象还是在栈上
};
int main()
{
	HeapOnly* p1 = HeapOnly::func();
	//HeapOnly p2(*p1);//这样避免了p2对象创建在栈上
	return 0;
}

#include<iostream>

using namespace std;

class HeapOnly
{
public:
	HeapOnly()
	{}
	void Delete()
	{
		this->~HeapOnly();
	}
private:
	~HeapOnly()
	{}
	HeapOnly(const HeapOnly& a) = delete;
};

int main()
{
	HeapOnly* p1 = new HeapOnly;
	p1->Delete();
	return 0;
}

#include <iostream>
using namespace std;
class NonInherit
{
public:
	static NonInherit func()
	{
		return NonInherit();
	}
	void Pintf()
	{
		cout << "Pintf" << endl;
	}
private:
	NonInherit()
	{}
	NonInherit(const NonInherit& p) = delete;
};
int main()
{
	NonInherit::func().Pintf();
	//static NonInherit p1 = NonInherit::func();//防止p1创建在静态区上
	return 0;
}

#include <iostream>
using namespace std;
class NonInherit
{
public:
	static NonInherit func()
	{
		return NonInherit();
	}
	void Pintf() const
	{
		cout << "Pintf" << endl;
	}
private:
	NonInherit()
	{}
	NonInherit(const NonInherit& p) = delete;
};
int main()
{
	const NonInherit& p1 = NonInherit::func();//用引用接收
	p1.Pintf();//然后在使用
	return 0;
}

#include<iostream>
#include<map>
#include<string>
using namespace std;
class Singleton
{
public:
	static Singleton& func()
	{
		return _a;//拿到对象本身
	}
	void Insert(string str, int salary)
	{
		arr[str] = salary;
	}
	void Printf()
	{
		for (auto& e : arr)
		{
			cout << e.first << ":" << e.second << endl;
		}
	}
private:
	Singleton()
	{}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	map<string, int> arr;
	static Singleton _a;
};
Singleton Singleton::_a;//在外部初始化对象，同类对象只会调用一次构造函数

int main()
{
	Singleton::func().Insert("aaa", 111);
	Singleton&p = Singleton::func();
	p.Insert("bbb", 222);
	p.Insert("ccc", 333);
	p.Insert("ddd", 444);
	p.Insert("eee", 555);
	p.Printf();
	return 0;
}

#include<iostream>
#include<map>
#include<string>
#include<mutex>
using namespace std;
template<class T>
class Lock
{
public:
	Lock(T& p)//因为锁不允许拷贝
		:_p(p)
	{
		_p.lock();
	}
	~Lock()
	{
		_p.unlock();
	}
private:
	T& _p;//所以这里成员用引用
};
class Singleton
{
public:
	static Singleton& func()
	{
		if (_a == nullptr)//避免每次调用的时候都进行加锁的操作，提高效率
		{
			Lock<mutex> p(mex);//用智能指针是为了防止下面的new出现异常导致未解锁
			//如果不加锁，容易发生内存泄露，开辟多个空间，最终指针只会指向一处空间
			if (_a == nullptr)//第一次调用创建对象
			{
				_a = new Singleton;
			}
		}
		return *_a;
	}
	void Insert(string str, int salary)
	{
		arr[str] = salary;
	}
	void Printf()
	{
		for (auto& e : arr)
		{
			cout << e.first << ":" << e.second << endl;
		}
	}
private:
	Singleton()
	{}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	map<string, int> arr;
	static Singleton* _a;
	static mutex mex;//锁
};
Singleton* Singleton::_a = nullptr;//在外部初始化对象，同类对象只会调用一次构造函数
mutex Singleton::mex;//定义锁
int main()
{
	Singleton::func().Insert("aaa", 111);
	Singleton& p = Singleton::func();
	p.Insert("bbb", 222);
	p.Insert("ccc", 333);
	p.Insert("ddd", 444);
	p.Insert("eee", 555);
	p.Printf();
	return 0;
}

static void Delete()//手动释放资源
{
	Lock<mutex> p(mex);
	if (_a != nullptr)
	{
		delete _a;
		_a = nullptr;
	}
}

class GC
{
public:
	~GC()
	{
		if (_a)
		{
			cout << "~GC()" << endl;
			Delete();
		}
	}
};

static Singleton& func()
{
	static Singleton _a;
	return _a;
}

#include<iostream>
using namespace std;

int main()
{
	//隐式类型
	int a = 1;
	double b = a;
	//强制类型
	int c = 10;
	int* p = &c;
	int d = (int)p;
	return 0;
}

#include<iostream>
using namespace std;
class A
{
public:
	virtual void f() {}
	int a;
};
class B : public A
{
public:
	int b;
};
void fun(A* pa)
{
	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
	B* pb = dynamic_cast<B*>(pa);//子类指向父类，访问父类的内容的时候虚表可能会越界产生报错
	if (pb)//检查是否合法，其实就是拒绝了子类指向父类
	{
		pb->a++;
		pb->b++;
		cout << "a++ " << "b++" << endl;
	}
}
int main()
{
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}