1,设计一个类,让该类不能被拷贝
//C++ 98 中将拷贝构造和赋值设置成私有(禁止类外面访问)
// 只声明不定义,因为不会被调用,所以定义没有意义
class A
{
private:
A(const A&);
A& operator=(const A&);
};
//C++11 引入了关键字delete,表示让编译器删除掉该默认成员函数
class B
{
B(const B&) = delete;
B& operator=(const B&) =delete;
};
2. 请设计一个类,只能在堆上创建对象
class C
{
public:
//如果这里不是静态的,需要传值给this指针
//然而对象还未在堆创建,又如何传呢?鸡生蛋,蛋生鸡。
//所以这里静态的成员函数解决了这个问题
static C* CreateObject()
{
return new C;
}
private:
C()
{
cout << "C()" << endl;
}
//如果通过拷贝构造和复制重载去创建对象会在栈上,要处理一下
C(const C&) = delete;
C& operator=(const C&) = delete;
};
3. 请设计一个类,只能在栈上创建对象
class D
{
public:
static D CreateObj()
{
return D();
}
//operaotr new和operator delete不会调用构造函数就可以生成对象
void* operator new(size_t size) = delete;
void operator delete(void* p)= delete ;
private:
D()
{}
};
4. 请设计一个类,不能被继承
C++ 98 构造函数私有化,父类无法调用子类的构造函数,无法被继承
C++11方法
final修饰类,表示该类不能被继承,
class E final
{
};
设计一个类,让其只能创建一个对象。
设计模式:是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
单例模式:一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个
访问它的全局访问点,该实例被所有程序模块共享。
单例模式实现的两种方式:饿汉模式和懒汉模式
饿汉模式:在main()函数执行之前就创建一个实例对象,不管用不用
优点:简单
缺点:如果实例对象时构造函数复杂,需要大量工作,可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定
懒汉模式:第一次调用实例化对象
优点:进程启动无负载。多个单例实例启动顺序自由控制。
缺点:复杂
//饿汉模式
class Singleton
{
public:
static Singleton* GetInstance()
{
return _inst;
}
void Print()
{
cout << " hahaha" << endl;
}
//防止拷贝和赋值去调用构造函数去实例化其他对象
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
Singleton()
{
//少量的初始化工作
}
static Singleton* _inst;
};
//这个在main函数之前就已经初始化完成了
Singleton* Singleton::_inst = new Singleton;
//懒汉模式
class Singleton
{
public:
static Singleton* GetInstace()
{
//双重锁
if (_inst == nullptr) //这个锁保证效率
{
_mux.lock(); //这个锁保证的是线程安全
_inst = new Singleton;
_mux.unlock();
}
return _inst;
}
~Singleton()
{
//析构只需要用一次,所以这里用一个垃圾回收类
}
class CGarbo //内部类相当于是友元类,可以访问类的私有变量
{
public:
~CGarbo()
{
if (_inst)
{
delete _inst;
_inst = nullptr;
}
}
};
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
Singleton()
{
//大量的初始化工作
}
static Singleton* _inst;
static mutex _mux;
static CGarbo CG; //定义一个静态的成员变量,程序结束的时候自动调用析构函数
//完成单例类的释放
};
Singleton* Singleton::_inst = nullptr;
mutex Singleton::_mux;
Singleton::CGarbo Singleton::CG;
//懒汉模式2,
//缺点:静态区比较小,不适合大的类对象
class Singleton
{
public:
static Singleton* GetInstance()
{
static Singleton inst; //借助静态的局部变量
return &inst;
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton) = delete;
private:
Singleton()
{
//大量的初始化工作
}
};