C++:特殊类设计

请设计一个类,不能被拷贝

拷贝只会放生在两个场景中:拷贝构造函数以及赋值运算符重载,因此想要让一个类禁止拷贝, 只需让该类不能调用拷贝构造函数以及赋值运算符重载即可

C++98: 将拷贝构造函数与赋值运算符重载只声明不定义,并且将其访问权限设置为私有即可。

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

C++11: C++11扩展delete的用法,delete除了释放new申请的资源外,如果在默认成员函数后跟上 =delete,表示让编译器删除掉该默认成员函数。

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

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

实现方式:

1. 将类的构造函数私有,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

2. 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建

// 只能在堆上创建对象的类
class HeapOnly
{
public:
	static HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()
	{}

	HeapOnly(const HeapOnly&) = delete;
};

int main()
{
	/*HeapOnly hp1;
	HeapOnly* php2 = new HeapOnly;
	static HeapOnly hp3;*/

	HeapOnly* php4 =  HeapOnly::CreateObj();

	//HeapOnly hp5(*php4);

	delete php4;

	cout << sizeof(php4) << endl;
	cout << sizeof(size_t) << endl;


	return 0;
}

这里注意,要防止拷贝构造,否则禁不住。

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

方法一:同上将构造函数私有化,然后设计静态方法创建对象返回即可。

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

    void Print() const
	{
		cout << "StackOnly::Print()" << endl;
	}

    // 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
    void* operator new(size_t size) = delete;
    void operator delete(void* p) = delete;
private:
    StackOnly()
        :_a(0)
    {}
private:
    int _a;
};

int main()
{
	//StackOnly so1 = StackOnly::CreateObj();
	static StackOnly so4 = StackOnly::CreateObj();

	//static StackOnly so2;
	//StackOnly* pso3 = new StackOnly;

	StackOnly::CreateObj().Print();

	const StackOnly& so5 = StackOnly::CreateObj();
	so5.Print();

	return 0;
}

但是只在栈上开辟是有瑕疵的,无法禁止静态对象拷贝构造。

请设计一个类,不能被继承

C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承。(不推荐)

C++11方法 final关键字,final修饰类,表示该类不能被继承。

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

RAII锁管理类

template<class Lock>
class LockGuard
{
public:
	LockGuard(Lock& lk)
		:_lk(lk)
	{
		_lk.lock();
	}

	~LockGuard()
	{
		_lk.unlock();
	}

private:
	Lock& _lk;
};

在标准库中使用

请设计一个类,只能创建一个对象(单例模式)

设计模式: 设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的 总结。

单例模式: 一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个 访问它的全局访问点,该实例被所有程序模块共享。

单例模式有两种实现模式:

饿汉模式

就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象

私有化构造,封死拷贝构造和赋值。

// 单例模式的类:全局只有一个唯一对象
// 饿汉模式:一开始(main函数之前)就创建对象
// 缺点:1、单例对象初始化时数据太多,导致启动慢
//      2、多个单例类有初始化依赖关系,饿汉模式无法控制
class InfoSingleton
{
public:
	static InfoSingleton& GetInstance()
	{
		return _sins;
	}

	void Insert(string name, int salary)
	{
		_info[name] = salary;
	}

	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

private:
	InfoSingleton()
	{}

	InfoSingleton(const InfoSingleton& info) = delete;
	InfoSingleton& operator=(const InfoSingleton& info) = delete;

private:
    map<string, int> _info;
	static InfoSingleton _sins;
};

InfoSingleton InfoSingleton::_sins;

int main()
{

	InfoSingleton::GetInstance().Insert("张三", 10000);
	InfoSingleton& infosl = InfoSingleton::GetInstance();
	infosl.Insert("李四", 15000);
	infosl.Insert("赵六", 12000);
	infosl.Insert("王五", 8000);
	infosl.Print();

	InfoSingleton::GetInstance().Insert("张三", 13000);
	InfoSingleton::GetInstance().Print();

	//InfoSingleton copy = InfoSingleton::GetInstance();
	//copy.Insert("孙七", 50000);
	//copy.Print();

	infosl.Print();

	return 0;
}

注意GetInstance返回的要是引用,封死拷贝构造和赋值,否则单例条件不成立。

懒汉模式

如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取 文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化, 就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。

饿汉模式还有一个问题,就是很难控制单例被初始化的顺序,比如A和B都是单例,B依赖A,在文件很多的情况下难以保证先初始化A。所以要解决这个问题,就使用懒汉模式。

// 懒汉模式:第一次获取单例对象的时候创建对象
// 1、对象在main函数之后才会创建,不会影响启动顺序
// 2、可以主动控制创建顺序
class InfoSingleton
{
public:
	// 多个线程一起调用GetInstance,存在线程安全的风险,

	static InfoSingleton& GetInstance()
	{
		// 第一次获取单例对象的时候创建对象
		// 双检查加锁
		if (_psins == nullptr)  // 对象new出来以后,避免每次都加锁的检查,提高性能
		{
			//LockGuard<mutex> lock(_smtx);
			std::lock_guard<mutex> lock(_smtx);

			if (_psins == nullptr)  // 保证线程安全且只new一次
			{
				_psins = new InfoSingleton;
			}	
		}

		return *_psins;
	}

	// 一般单例对象不需要考虑释放
	// 单例对象不用时,必须手动处理,一些资源需要保存
	// 可以手动调用主动回收
	// 也可以让他自己在程序结束时,自动回收
	static void DelInstance()
	{
		// 保存数据到文件
		// ...

		std::lock_guard<mutex> lock(_smtx);
		if (_psins)
		{
			delete _psins;
			_psins = nullptr;
		}
	}

	// 也可以让他自己在程序结束时,自动回收
	class GC
	{
	public:
		~GC()
		{
			if (_psins)
			{
				cout << "~GC()" << endl;
				DelInstance();
			}
		}
	};
	
	void Insert(string name, int salary)
	{
		_info[name] = salary;
	}

	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

private:
	InfoSingleton()
	{}

	InfoSingleton(const InfoSingleton& info) = delete;
	InfoSingleton& operator=(const InfoSingleton& info) = delete;


	map<string, int> _info;
	// ...

private:
	static InfoSingleton* _psins;
	static mutex _smtx;
	static GC _gc;
};

InfoSingleton* InfoSingleton::_psins = nullptr;
mutex InfoSingleton::_smtx;
InfoSingleton::GC InfoSingleton::_gc;

int main()
{

	InfoSingleton::GetInstance().Insert("张三", 10000);
	InfoSingleton& infosl = InfoSingleton::GetInstance();
	infosl.Insert("李四", 15000);
	infosl.Insert("赵六", 12000);
	infosl.Insert("王五", 8000);
	infosl.Print();

	InfoSingleton::GetInstance().Insert("张三", 13000);
	InfoSingleton::GetInstance().Print();

	infosl.Print();
	return 0;
}

使用双检查锁,保证线程安全和效率(只加一次锁)。

实现一个内嵌垃圾回收类GC在不使用单例后释放资源(虽然在本程序中没意义)。

懒汉模式还可以通过局部静态变量初始化实现:

//1、是懒汉。 因为静态的局部变量是在main函数之后才创建初始化的
//2、C++11之前,这里是不能保证sinst的初始化是线程安全的。
//3、C++11之后,可以。
class InfoSingleton
{
public:
	static InfoSingleton& GetInstance()
	{
		static InfoSingleton sinst;
		return sinst;
	}

	void Insert(string name, int salary)
	{
		_info[name] = salary;
	}

	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

private:
	InfoSingleton()
	{
		cout << "InfoSingleton()" << endl;
	}

	InfoSingleton(const InfoSingleton& info) = delete;
	InfoSingleton& operator=(const InfoSingleton& info) = delete;


	map<string, int> _info;
	// ...
};

但是这种方式要慎重,在C++11前不是线程安全的,在C++11后才是线程安全的。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JDSZGLLL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值