C++智能指针的补充和特殊类的设计示例详解

int main()
{
	txf::shared_ptr<A> sp1(new A(1));
	return 0;
}

int main()
{
	txf::shared_ptr<A> sp1(new A(1));
    txf::shared_ptr<A> sp2(new A[10]);
	return 0;
}

int main()
{
	txf::shared_ptr<A> sp1(new A(1));

	txf::shared_ptr<A> sp2(new A[10]);// DeleteArray<A>()匿名对象
	
	txf::shared_ptr<A> sp3((A*)malloc(sizeof(A)))；
	return 0;
}

		template<class D>
		shared_ptr(T* ptr,D del)
			:_ptr(ptr) 
            ,_pcount(new int(1))
		{
		}

	template<class D>
	shared_ptr(T* ptr,D del)
		:_ptr(ptr) ,_pcount(new int(1)),_del(del)
	{
	}

private:
	T* _ptr;
	int* _pcount;
	
	D _del；

	private:
		T* _ptr;
		int* _pcount;
		//D _del //D是构造函数的模板参数，不是类模板的模板参数,不能这么写；
		//我们要在析构函数用到del,但是del在构造函数怎么办？
		// 我们可以用它来创建一个成员变量,但是他类型是什么？
		// 因为D这个是专门在构造函数，才能用的,不是构造函数，不能写D类型,
		// 不能明确他的类型,那我们怎样创建一个成员中间？
		// 如果说del成员专门写成仿函数类型，那如果传的是函数指针或者lambda怎么办呢？
		// 这里我们就要用前面讲的包装器，包装器可以接收他们仨个类型中的任意一个类型
		 
		function<void(T*)> _del
		 //void : 被调用函数的返回类型
		 // T* ：被调用函数的形参
		//int _pcount 如果是这样，每个对象的_pcount都是独立的
		

template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};

int main()
{
	txf::shared_ptr<A> sp1(new A(1));
	//由于这里的虚构函数是写死的 如果这样写呢？
	txf::shared_ptr<A> sp2(new A[10], DeleteArray<A>());// DeleteArray<A>()匿名对象
	//那这里有九个对象，还没有释放
	//甚至如果说这里是malloc 
	txf::shared_ptr<A> sp3((A*)malloc(sizeof(A)), [](A* ptr) {free(ptr); });
	//我们之前就说过malloc匹配free， new要匹配delete，这就明显是不匹配的，不匹配就会出问题
	//那库里面是怎么解决这个问题的呢？->定制删除器(仿函数）
	return 0;
}

	~shared_ptr()
	{
		if (--(*_pcount) == 0)
		{
			cout << "delete:" << _ptr << endl;
			_del(_ptr);
			delete _pcount;
		}
	}

private:
	T* _ptr;
	int* _pcount;

	function<void(T*)> _del = [](T* ptr) {delete ptr; };//要先给一个lambda，要不然这个就专门设计成了处理多个对象的了,反而处理当个对象就不行了,所以还要再写一个拷贝函数
	 //void : 被调用函数的返回类型
	 // T* ：被调用函数的形参
	
};

	shared_ptr(T* ptr)
		:_ptr(ptr), _pcount(new int(1))
	{
	}

	template<class D>
	shared_ptr(T* ptr,D del)
		:_ptr(ptr) ,_pcount(new int(1)),_del(del)
	{
	}

class A
{
    // ...
    
private:
    A(const A&);
    A& operator=(const A&);
    //...};

class A
{
    // ...
    
    A(const A&)=delete;
    A& operator=(const A&)=delete;
    //...};

int main()
{
	HeapOnly hp1;//创建在栈上
	static HeapOnly hp2;//创建在静态区上
	HeapOnly* hp3 = new HeapOnly;//创建在堆上

	return 0;
}

class HeapOnly
{
public:
	void Destroy()
	{
		cout << " deletec  : " << this << endl;
		delete this;
	}	
private:
	~HeapOnly()
	{

	}
};

class HeapOnly
{
public:
	void Destroy()
	{
		cout << " deletec  : " << this << endl;
		delete this;
	}
	HeapOnly* CreateObj()
    {
	}
	
private:
	~HeapOnly()
	{

	}
	HeapOnly()
	{

	}
};

static HeapOnly* CreateObj()//static让  CreateObj()  脱离对象，变成“类名::函数”这种普通全局入口
{                           //让它变成静态区的一个函数，变成一个用类名调用函数的形式，声明类就可以调用，
							// 这样不用非得要一个对象才能调用这个函数

	return new HeapOnly;//但是此时面临个问题
	//他不像是析构函数，使用已经创建好的对象去调用一个函数，
	// 他这里是需要创建一个对象去给一个指针，但是谁来调用这个函数呢？
	// 我们并没有对象，我们还要靠这个函数来创造对象，
	// 但是又需要一个对象来调用这个函数
	//这就有点像是先有鸡还是先有蛋的问题
}

HeapOnly hp4(*hp3);

private:
	~HeapOnly()
	{

	}
	HeapOnly()
	{

	}
	HeapOnly(const HeapOnly& hp) = delete;
	HeapOnly&  operator=(const HeapOnly& hp) = delete;

class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		StackOnly st;
		return st;
	}

private:
	StackOnly()
	{ }
};

int main()
{
	StackOnly sp1= StackOnly::CreateObj();
	return 0;
}

	StackOnly* sp2 = new StackOnly(sp1); 

class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		StackOnly st;
		return st;
	}

private:
	StackOnly()
	{ }

	void* operator new(size_t size) = delete;//把通往堆的所有后门（operator new）全部焊死
};

int main()
{
	StackOnly sp1= StackOnly::CreateObj();

	//StackOnly* sp2 = new StackOnly(sp1); //这样就不能拷贝了
	
	return 0;
}

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

class A  final
{
    // ....
};

class singleton
{
public:
	//步骤二
	//提供获取单例对象的接口函数
	static singleton&  GetInstance()
	{
		return _sinst;
	}

	
	// singleton sinst;

	//一般单例不用释放


	void Add(const pair<string, string>& kv)
	{
		_dict[kv.first] = kv.second;
	}

private:
	//单例模式步骤一
	//构造函数私有
	map<string, string> _dict;
	singleton()
	{

	}

	//步骤三
	//防拷贝
	singleton (const singleton& s) = delete;
	singleton& operator=(const singleton& s) = delete;

	static singleton _sinst;//声明一个成员变量
};

//类的静态成员变量需要在类外初始化
 singleton singleton:: _sinst;//实例化变量
 //虽然存储在静态区，但由于在singleton类中声明了，所以它依然能享用到构造函数，而且在静态区，所以只用声明在哪个类域


int main()
{
	//singleton s1;//不能随意创建对象
	//singleton s2;
	//if (&s1 == &s2)
	//{
	//	cout << "a" << endl;
	//}
	//else
	//{
	//	cout << " b";
	//}

	//cout << &singleton::GetInstance() << endl;
	//cout << &singleton::GetInstance() << endl;
	//cout << &singleton::GetInstance() << endl;

	//还要把拷贝给禁掉，要不然还能拷贝
	//singleton copy(singleton::GetInstance());
  return 0;
}

class singleton
{
public:
  
private:
	//单例模式步骤一
	//构造函数私有
	singleton()
	{

	}
}：

class singleton
{
public:
      	//步骤二
	//提供获取单例对象的接口函数
	static singleton&  GetInstance()
	{
		return _sinst;
	}
private:
	//单例模式步骤一
	//构造函数私有
	singleton()
	{

	}
}：

  singleton copy(singleton::GetInstance());

class singleton
{
public:
	//步骤二
	//提供获取单例对象的接口函数
	static singleton&  GetInstance()
	{
		return _sinst;
	}

	
	// singleton sinst;

	//一般单例不用释放


	void Add(const pair<string, string>& kv)
	{
		_dict[kv.first] = kv.second;
	}

private:
	//单例模式步骤一
	//构造函数私有
	map<string, string> _dict;
	singleton()
	{

	}

	//步骤三
	//防拷贝
	singleton (const singleton& s) = delete;
	singleton& operator=(const singleton& s) = delete;

	static singleton _sinst;//声明一个成员变量
};

//类的静态成员变量需要在类外初始化
 singleton singleton:: _sinst;//实例化变量
 //虽然存储在静态区，但由于在singleton类中声明了，所以它依然能享用到构造函数，而且在静态区，所以只用声明在哪个类域

namespace lazy
{
	class Singleton
	{
	public:
		static Singleton& GetInstace()
		{
			if (_sinst == nullptr)
			{
				_sinst = new Singleton();
			}

			return *_sinst;
		}

	private:
		Singleton()
		{}

		Singleton(const Singleton& _sinst) = delete;
		Singleton& operator=(const Singleton& _sinst) = delete;

		static Singleton* _sinst;
	};

	Singleton* Singleton::_sinst = nullptr;
}