目次
2. ヒープ上にのみオブジェクトを作成できるクラスを設計する
3. スタック上でのみオブジェクトを作成できるクラスを設計する
5. 1 つのオブジェクトしか作成できないクラスを設計する (シングルトン モード)
1.コピーできないクラスを設計する
コピーは、コピー コンストラクターと代入演算子のオーバーロードの 2 つのシナリオでのみ表示されるため、クラスでコピーを禁止する場合は、クラスがコピー コンストラクターと代入演算子のオーバーロードを呼び出せないようにするだけで済みます。
C++98 では、コピー構築と代入オーバーロードのみが宣言され、実装されません。これら 2 つのメンバー関数はプライベートとして設定できます。private に設定した後は、クラス外で呼び出すことはできません.宣言により、コンパイラはデフォルトで生成しません。
class CopyBan
{
// ...
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//...
};The use of delete is extended in C++11. new によって要求されたリソースを解放することに加えて、delete が =delete を使用して既定のメンバー関数に続く場合、コンパイラが既定のメンバー関数を削除することを意味します。
class CopyBan
{
// ...
CopyBan(const CopyBan&)=delete;
CopyBan& operator=(const CopyBan&)=delete;
//...
};2. ヒープ上にのみオブジェクトを作成できるクラスを設計する
まず、クラスのコンストラクターをプライベートにし、コピー コンストラクターをプライベートとして宣言します。他の人がコピー構築を呼び出してスタック上にオブジェクトを生成するのを防ぎます。次に、静的メンバー関数を提供し、静的メンバー関数でヒープ オブジェクトの作成を完了します。
class HeapOnly
{
public:
static HeapOnly* createOBJ()
{
return new HeapOnly;
}
private:
HeapOnly()
{}
HeapOnly(const HeapOnly&) = delete;
};
デストラクタをプライベートにすることもできます。スペースを解放するときは、クラスのインターフェイスを介して解放できます。
3. スタック上でのみオブジェクトを作成できるクラスを設計する
上記のようにコンストラクタをprivate化し、オブジェクトを作成して返す静的メソッドを設計する.ここで、他の場所でのオブジェクトの作成を完全に禁止することはできないことに注意してください.
4. 継承できないクラスを設計する
C++98では基底クラスの構築が非公開化されており、派生クラスで基底クラスのコンストラクタを継承できない場合は継承できません。
// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};最終的に変更されたクラスである C++11 の final キーワードは、クラスを継承できないことを意味します。
class A final
{
// ....
};5. 1 つのオブジェクトしか作成できないクラスを設計する (シングルトン モード)
デザインパターン (Design Pattern) は、繰り返し使用され、ほとんどの人が知っている一連のコード設計経験をまとめたものです。
デザイン パターンを使用する目的: コードの再利用性、他のユーザーがコードを理解しやすくすること、およびコードの信頼性を確保すること。デザイン パターンは
、コード ライティングを真のエンジニアリングにします。デザイン パターンは、建物の構造と同様に、ソフトウェア エンジニアリングの基礎です。
イテレータモード、アダプタ（アダプタ）モード、シングルトンモード、ファクトリーモード、オブザーバーモードなど。これらは設計パターンです。
シングルトンパターン
クラスは 1 つのオブジェクト (シングルトン モード) のみを作成できます。これにより、システム内にクラスのインスタンスが 1 つだけ存在することが保証され、それにアクセスするためのグローバル アクセス ポイントが提供されます。このアクセス ポイントは、すべてのプログラム モジュールによって共有されます。
たとえば、サーバー プログラムでは、サーバーの構成情報がファイルに格納され、これらの構成データがシングルトン オブジェクトによって一律に読み取られ、サービス プロセス内の他のオブジェクトがこのシングルトン オブジェクトを介して構成情報を取得します。このアプローチにより、複雑な環境での構成管理が簡素化されます。
シングルトン モードには 2 つの実装モードがあります。
飢えた男モード
プログラムの開始時 (メイン関数の前) に、一意のインスタンス オブジェクトが作成されます。
class Singleton
{
public:
static Singleton& create()
{
return _sins;
}
void Insert(string s, int money)
{
//_info.insert(make_pair(s, money));
_info[s] = money;
}
void Print()
{
for (const auto& kv : _info)
{
cout << kv.first << ":" << kv.second << endl;
}
cout << endl;
}
private:
Singleton()
{}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
map<string, int> _info;
static Singleton _sins;
};
Singleton Singleton::_sins;//初始化実際には、コピーして割り当てることができないオブジェクトが 1 つしかないことがわかります。
利点: 1. シンプル2. シングルトン オブジェクトは、マルチスレッドの高同時実行環境で頻繁に使用され、高いパフォーマンスが要求されます. リソースの競合を回避し、応答速度を向上させるには、ハングリーマン モードを使用することをお勧めします.
短所: 1. シングルトン オブジェクトの初期化時にデータが多すぎるため、起動が遅くなります。
2. 複数のシングルトン クラスの初期化には依存関係があり、ハングリーマン モードを制御できません。複数のシングルトン クラス オブジェクト インスタンスの起動順序が不明であるためです。
レイジーモード
オブジェクトはメイン関数の後に作成され、起動シーケンスには影響しません。作成シーケンスもアクティブに制御できます。
//template<class lock>
//class lockGuard //智能指针->自动加锁，解锁 RAII方式
//{
//public:
// lockGuard(lock& lk)
// :_lk(lk)
// {
// _lk.lock();
// }
// ~lockGuard()
// {
// _lk.unlock();
// }
//private:
// lock& _lk;
//};
//懒汉模式
class Singleton
{
public:
//static Singleton& create()
//{
// //第一次获取单列对象的时候创建对象
// //双检查加锁
// if (_psins == nullptr)//对象new出来以后，避免每次都加锁检查，提高性能
// {
// _mtx.lock();
// if (_psins == nullptr)//保证线程安全且只new一次
// {
// _psins = new Singleton; //如果new抛异常，就没有解锁
// }
// _mtx.unlock();
// }
// return *_psins;
//}
static Singleton& create()
{
//第一次获取单列对象的时候创建对象
//双检查加锁
if (_psins == nullptr)//对象new出来以后，避免每次都加锁检查，提高性能
{
//lockGuard<mutex> mtx(_mtx); //自己实现的
std::lock_guard<mutex> mtx(_mtx);//库里提供的
if (_psins == nullptr)//保证线程安全且只new一次
{
_psins = new Singleton;
}
}
return *_psins;
}
//插入
void Insert(string s, int money)
{
//_info.insert(make_pair(s, money));
_info[s] = money;
}
void Print()
{
for (const auto& kv : _info)
{
cout << kv.first << ":" << kv.second << endl;
}
cout << endl;
}
//一般单例对象不需要考虑释放
//单例对象不用时，必须手动处理，一些资源需要保存
static void DelInstance()
{
//保存数据到文件
//...
std::lock_guard<mutex> lock(_mtx);
if (_psins)
{
delete _psins;
_psins = nullptr;
}
}
//自动回收
class GC
{
public:
~GC()
{
if (_psins)//如果你没有显示的释放，我就帮你回收
{
cout << "~GC()" << endl;
DelInstance(); //内部类是外部类的友元，可以直接调用
}
}
};
private:
Singleton()
{}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
map<string, int> _info;
static Singleton* _psins;
static mutex _mtx;
static GC _gc;
};
Singleton* Singleton::_psins = nullptr;//初始化
mutex Singleton::_mtx;
Singleton::GC Singleton::_gc;
利点: オブジェクトは、インスタンス オブジェクトが初めて使用されるときに作成されます。プロセスは無負荷で開始されます。複数シングルトンインスタンス起動順序自由制御システム。短所: 複雑で、多くの問題に注意を払う必要があります。
拡大：
//懒汉模式
class Singleton
{
public:
static Singleton& create()
{
static Singleton sins; //只会创建一次
return sins;
}
//插入
void Insert(string s, int money)
{
//_info.insert(make_pair(s, money));
_info[s] = money;
}
void Print()
{
for (const auto& kv : _info)
{
cout << kv.first << ":" << kv.second << endl;
}
cout << endl;
}
private:
Singleton()
{
cout << "Singleton()" << endl;
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
map<string, int> _info;
};
メイン関数の後に静的ローカル変数が作成および初期化されるため、これも遅延モードです。
C++11 より前では、sins の初期化がスレッドセーフであることが保証されていませんが、C++11 以降では保証されています。以前は C++11 ではこの領域が規定されていなかったため、コンパイラの実装ごとに異なりますが、C++11 以降では、静的ローカル変数はスレッドセーフである必要があると規定されています。この点については、インターネット上に多くの指示があります。自分で確認できます。