1. 一个类: 只能在堆上创建对象
关键点:自己控制析构
1.1 方法一: 使用delete禁掉默认析构函数
#include <iostream>
using namespace std;
class HeapOnly
{
public:
HeapOnly()
{
_str = new char[10];
}
~HeapOnly() = delete;
void Destroy()
{
delete[] _str;
operator delete(this);
}
private:
char* _str;
//...
};
int main()
{
HeapOnly* ptr = new HeapOnly;
ptr->Destroy();
return 0;
}
- 只要在堆上申请空间,并且使用delete把析构函数禁掉就行了
- 自己再实现一个释放空间的函数
1.2 方法二: 将析构函数私有化
#include <iostream>
#include <stdlib.h>
using namespace std;
class HeapOnly
{
public:
/*static void Delete(HeapOnly* p)
{
delete p;
}*/
void Delete()
{
delete this;
}
private:
// 析构函数私有
~HeapOnly()
{
cout << "~HeapOnly()" << endl;
}
private:
int _a;
};
int main()
{
//HeapOnly hp1;// error
//static HeapOnly hp2;// error
HeapOnly* ptr = new HeapOnly;
ptr->Delete();
return 0;
}
1.3 方法三: 将构造函数私有化(禁掉拷贝)
#include <iostream>
#include <stdlib.h>
using namespace std;
class HeapOnly
{
public:
// 提供一个公有的,获取对象的方式,对象控制是new出来的
static HeapOnly* CreateObj()
{
return new HeapOnly;
}
// 防拷贝
HeapOnly(const HeapOnly& hp) = delete;
HeapOnly& operator=(const HeapOnly& hp) = delete;
private:
// 构造函数私有
HeapOnly()
:_a(0)
{}
private:
int _a;
};
int main()
{
/*HeapOnly hp1;
static HeapOnly hp2;
HeapOnly* hp3 = new HeapOnly;
delete hp3;*/
HeapOnly* hp3 = HeapOnly::CreateObj();
//HeapOnly copy(*hp3);
delete hp3;
return 0;
}
直接将构造函数私有化,然后再实现一个CreatObj创建对象,返回值是static;
创建的是堆的话,需要禁掉那2个函数
2. 一个类: 只能在栈上创建对象
关键点: 自己控制构造
2.1 方法一: 构造函数私有化(禁掉new)
#include <iostream>
#include <stdlib.h>
using namespace std;
class StackOnly
{
public:
static StackOnly CreateObj()
{
StackOnly st;
return st;
}
// 不能防拷贝
//StackOnly(const StackOnly& st) = delete;
//StackOnly& operator=(const StackOnly& st) = delete;
void* operator new(size_t n) = delete;
private:
// 构造函数私有
StackOnly()
:_a(0)
{}
private:
int _a;
};
int main()
{
/*StackOnly st1;
static StackOnly st2;
StackOnly* st3 = new StackOnly;*/
StackOnly st1 = StackOnly::CreateObj();
// 拷贝构造
static StackOnly copy2(st1); // 不好处理,算是一个小缺陷
//StackOnly* copy3 = new StackOnly(st1);
return 0;
}
3. 一个类:不能被继承
3.1 给父类加final关键字
#include <iostream>
#include <string>
using namespace std;
//C98
//class A
//{
//private:
// A()
// {}
//
//protected:
// int _a;
//};
// C++11中引用的final
class A final
{
public:
A()
{}
protected:
int _a;
};
class B : public A
{
};
int main()
{
B bb;// 这里对象实例化才会报错
return 0;
}
-
C++98中:a. 父类构造函数私有-- 子类是不可见,b. 这种只有对象实例化才会报错
-
C++11中:给父类加上了final关键字,使子类不能继承父类,
4. 一个类: 只能创建一个对象(单例模式)
4.1 单例模式(饿汉模式 && 懒汉模式)
那两种模式都是将构造函数私有化,自己实现一个构造生成一个静态对象
- 一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个 访问它的全局访问点,该实例被所有程序模块共享
4.2 饿汉模式: 程序启动时就创建一个唯一的实例对象
class Singleton
{
public:
static Singleton* GetInstance()
{
return &m_instance;
}
private:
// 构造函数私有
Singleton() {};
// C++11 : 防拷贝
Singleton(Singleton const&) = delete;
Singleton& operator=(Singleton const&) = delete;
static Singleton m_instance;// 声明
};
Singleton Singleton::m_instance;// 定义
-
优点:简单
-
缺点:可能会导致进程启动慢,且如果 有多个单例类对象实例启动顺序 不确定。
-
总结: 如果这个单例对象在多线程高并发环境下频繁使用,性能要求较高,那么显然使用饿汉模式来避 免资源竞争,提高响应速度更好。
4.3 懒汉模式 : 第一次使用对象再创建实例对象
- 如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取 文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,
- 就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。
#include <iostream>
#include <stdlib.h>
using namespace std;
class MemoryPool
{
public:
static MemoryPool* GetInstance()
{
if (_pinst == nullptr) {
_pinst = new MemoryPool;
}
return _pinst;
}
void* Alloc(size_t n)
{
void* ptr = nullptr;
// ....
return ptr;
}
void Dealloc(void* ptr)
{
// ...
}
// 实现一个内嵌垃圾回收类
class CGarbo {
public:
~CGarbo()
{
if (_pinst)
delete _pinst;
}
};
private:
// 构造函数私有化
MemoryPool()
{
// ....
}
char* _ptr = nullptr;
// ...
static MemoryPool* _pinst; // 声明
};
// 定义
MemoryPool* MemoryPool::_pinst = nullptr;
// 回收对象,main函数结束后,他会调用析构函数,就会释放单例对象
static MemoryPool::CGarbo gc;
int main()
{
void* ptr1 = MemoryPool::GetInstance()->Alloc(10);
MemoryPool::GetInstance()->Dealloc(ptr1);
}
- 优点: 有控制顺序, 不影响启动速度
- 缺点: 相对复杂, 存在线程安全问题
4.4 单例对象释放问题:
- 一般情况下,单例对象不需要释放的。因为一般整个程序运行期间都可能会用它。单例对象在进程正常结束后,也会资源释放。
- 有些特殊场景需要释放,比如单例对象析构时,要进行一些持久化(往文件、数据库写)操作。