C++特殊类设计及类型转换举例详解

class copyban
{
private:
	copyban(const copyban&);
	copyban& operator=(const copyban&);

	//...
};

class copyban
{
	// ...

	copyban(const copyban&) = delete;
	copyban& operator=(const copyban&) = delete;

	//...

};

class heaponly
{
public:
    //提供在堆上创建对象的方法
	static heaponly* createobj()
	{
		return new heaponly;
	}

	//将拷贝构造和赋值重载也禁止
	heaponly(const heaponly&) = delete;
	heaponly& operator=(const heaponly&) = delete;
private:
	//将构造私有，防止外界直接创建对象
	heaponly()
	{}
};

int main()
{
	//静态区上创建对象
	//static heaponly hp0;
	
	// 栈上创建对象
	//heaponly hp1;
	
	//堆上创建对象
	//heaponly* hp2 = new heaponly;

	heaponly* hp3 = heaponly::createobj();
	
	//要防止别人通过这种方式在栈上创建对象
	//通过禁止拷贝构造来防止这种方式
	//heaponly hp4(*hp3);

	//手动释放堆上的资源
	delete hp3;

	return 0;
}

class heaponly
{
public:
	void destroy()
	{
		delete this;
	}

private:
	//析构函数私有化
	~heaponly()
	{}
};

int main()
{
	//static heaponly hp0;
	//heaponly hp1;
	heaponly* hp2 = new heaponly;
	//delete hp2;
	hp2->destroy();

	return 0;
}

class stackonly
{
public:
	static stackonly createobj()
	{
		return stackonly();
	}

	//stackonly(const stackonly& s) = delete;
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
private:
	stackonly()
		:_a(0)
	{}
private:
	int _a;
};

int main()
{
	//static stackonly s1;
	//stackonly s2;
	//stackonly* s3 = new stackonly;

	stackonly s4 = stackonly::createobj();

	//stackonly* s5 = new stackonly(s4);
	static stackonly s6(s4);

	return 0;
}

class stackonly
{
public:
	static stackonly createobj()
	{
		return stackonly();
	}

	stackonly(const stackonly&& s)
	{
		//......
	}

	stackonly(const stackonly& s) = delete;
private:
	stackonly()
		:_a(0)
	{}
private:
	int _a;
};

int main()
{
	stackonly s4 = stackonly::createobj();

	//stackonly* s5 = new stackonly(s4);
	//static stackonly s6(s4);

	//这种方式禁止不掉
	stackonly* s5 = new stackonly(move(s4));
	static stackonly s6(move(s4));

	return 0;
}

// c++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class noninherit
{
public:
	static noninherit getinstance()
	{
		return noninherit();
	}

private:
	noninherit()
	{}
};

class a final
{
	// ....
};

// 饿汉模式
// 1、多个饿汉模式的单例，某个对象初始化内容较多(读文件)，会导致程序启动慢
// 2、a和b两个饿汉，对象初始化存在依赖关系，要求a先初始化，b再初始化，饿汉无法保证
class infomgr
{
public:
	static infomgr& getinstance()
	{
		return _ins;
	}

	void print()
	{
		cout << _ip << endl;
		cout << _port << endl;
		cout << _buffsize << endl;
	}
private:
	infomgr(const infomgr&) = delete;
	infomgr& operator=(const infomgr&) = delete;

	infomgr()
	{
		cout << "infomgr()" << endl;
	}
private:
	string _ip = "127.0.0.1";
	int _port = 80;
	size_t _buffsize = 1024 * 1024;
	//...

	static infomgr _ins;
};

infomgr infomgr::_ins;


int main()
{
	infomgr::getinstance().print();
	//infomgr copy(infomgr::getinstance());

	return 0;
}

// 懒汉模式
class infomgr
{
public:
	static infomgr& getinstance()
	{
		// 第一次调用时创建单例对象
		// 有线程安全的风险
		if (_pins == nullptr)
		{
			_pins = new infomgr;
		}

		return *_pins;
	}

	void print()
	{
		cout << _ip << endl;
		cout << _port << endl;
		cout << _buffsize << endl;
	}

	static void delinstance()
	{
		delete _pins;
		_pins = nullptr;
	}

private:
	infomgr(const infomgr&) = delete;
	infomgr& operator=(const infomgr&) = delete;

	infomgr()
	{
		cout << "infomgr()" << endl;
	}
private:
	string _ip = "127.0.0.1";
	int _port = 80;
	size_t _buffsize = 1024 * 1024;
	//...

	static infomgr* _pins;
};

infomgr* infomgr::_pins = nullptr;

int main()
{
	infomgr::getinstance().print();
	infomgr::getinstance().print();

	return 0;
}

class infomgr
{
public:
	static infomgr& getinstance()
	{
		// 第一次调用时创建单例对象
		// c++11之后
		static infomgr ins;
		return ins;
	}

	void print()
	{
		cout << _ip << endl;
		cout << _port << endl;
		cout << _buffsize << endl;
	}
private:
	infomgr(const infomgr&) = delete;
	infomgr& operator=(const infomgr&) = delete;

	infomgr()
	{
		cout << "infomgr()" << endl;
	}
private:
	string _ip = "127.0.0.1";
	int _port = 80;
	size_t _buffsize = 1024 * 1024;
	//...
};

int main()
{
	infomgr::getinstance().print();
	infomgr::getinstance().print();

	cout << &infomgr::getinstance() << endl;
	cout << &infomgr::getinstance() << endl;

	return 0;
}

// a、内置类型之间
// 1、隐式类型转换    整形之间/整形和浮点数之间
// 2、显示类型的转换  指针和整形、指针之间

int main()
{
	int i = 1;
	// 隐式类型转换
	double d = i;
	printf("%d, %.2f\n", i, d);

	int* p = &i;
	// 显示的强制类型转换
	int address = (int)p;
	printf("%p, %d\n", p, address);

	return 0;
}

// b、内置类型和自定义类型之间
// 1、自定义类型 = 内置类型  ->构造函数支持
// 2、内置类型 = 自定义类型
class a
{
public:
	//explicit a(int a) //explicit关键字可以禁止隐式转换，必须显示转换
	a(int a)
		:_a1(a)
		,_a2(a)
	{}

	a(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}

	//自定义类型 -> 内置类型
	// ()被仿函数占用了，不能用
	// operator 类型实现，有返回值，无返回类型
	// 默认返回类型就是要转换的类型
 	//explicit operator int()
	operator int()
	{
		return _a1 + _a2;
	}
private:
	int _a1 = 1;
	int _a2 = 1;
};
int main()
{
	//内置类型转换自定义类型
	string s1 = "1111111";

	a aa1 = 1;
	//a aa1 = (a)1;

	a aa2 = { 2,2 };
	const a& aa3 = { 2,2 };

	//自定义类型转换内置类型
	int z = aa1.operator int();
	//int x = (int)aa1;
	int x = aa1;
	int y = aa2;
	cout << x << endl;
	cout << y << endl;

	//库里的shared_ptr提供了转换为bool类型的重载函数
	std::shared_ptr<int> foo;
	std::shared_ptr<int> bar(new int(34));

	//这里本质是转换为了bool类型
	//if (foo.operator bool())
	if (foo)
		std::cout << "foo points to " << *foo << '\n';
	else 
		std::cout << "foo is null\n";

	if (bar)
		std::cout << "bar points to " << *bar << '\n';
	else
		std::cout << "bar is null\n";

	return 0;
}

// c、自定义类型和自定义类型之间 -- 对应的构造函数支持
class a
{
public:
	a(int a)
		:_a1(a)
		, _a2(a)
	{}

	a(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}

	int get() const
	{
		return _a1 + _a2;
	}
private:
	int _a1 = 1;
	int _a2 = 1;
};

class b
{
public:
	b(int b)
		:_b1(b)
	{}

	b(const a& aa)
		:_b1(aa.get())
	{}

private:
	int _b1 = 1;
};

#include"list.h"
#include<list>

int main()
{
	a aa1(1);
	b bb1(2);

	bb1 = aa1;
	b& ref1= bb1;
	const b& ref2 = aa1;

	bit::list<int> lt = { 1,2,3,4 };
	// 权限的缩小？权限缩小和放大，仅限于const的指针和引用
	// 不是权限缩小，这里类型转换
	bit::list<int>::const_iterator cit = lt.begin();
	while (cit != lt.end())
	{
		cout << *cit << " ";
		++cit;
	}
	cout << endl;

	return 0;
}

int main()
{
	// 对应隐式类型转换 -- 数据的意义没有改变
	double d = 12.34;
	int a = static_cast<int>(d);
	cout << a << endl;

	return 0;
}

int main()
{
	// 对应隐式类型转换 -- 数据的意义没有改变
	double d = 12.34;
	int a = static_cast<int>(d);
	cout << a << endl;
	
	// 对应强制类型转换 -- 数据的意义已经发生改变
	int* p1 = reinterpret_cast<int*>(a);;

	return 0;
}

int main()
{
	// 对应强制类型转换中有风险的去掉const属性
	//volatile const int b = 2;
	const int b = 2;
	int* p2 = const_cast<int*>(&b);
	*p2 = 3;

	cout << b << endl;
	cout << *p2 << endl;

	return 0;
}

class a
{
public:
	virtual void f() {}

	int _a = 1;
};

class b : public a
{
public:
	int _b = 2;
};

void fun(a* pa)
{
	// dynamic_cast会先检查是否能转换成功(指向子类对象)，能成功则转换，
	// (指向父类对象)不能则返回null
	// 指向父类转换时有风险的，后续访问存在越界访问的风险
	// 指向子类转换时安全
	b* pb1 = dynamic_cast<b*>(pa);
	if (pb1)
	{
		cout << "pb1:" << pb1 << endl;
		cout << pb1->_a << endl;
		cout << pb1->_b << endl;
		pb1->_a++;
		pb1->_b++;
		cout << pb1->_a << endl;
		cout << pb1->_b << endl;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}

int main()
{
	a a;
	b b;
	fun(&a);
	fun(&b);

	return 0;
}