C++-シミュレーション関数の実現原理と応用

3627 ワード
C++ 対象に向ける スマートポインタ 擬似関数
C++擬似関数
今日は冷たいですが面白い知識->模倣関数を見てみましょう.名前を聞いてみると、彼は関数ではないことを知っています.
のものは関数の機能を持っていて、私たちが前に言ったスマートポインタと似ています.では、私たちは->クラス、間違っていません.これがクラスです.
これが対象に向かう長所で、以前は対象に向かうメリットを体得できなかったが、今では勉強すればするほど役に立つようになった.
この概念は、通俗的な点として、一つのクラスで演算子を用いて「()」を再ロードし、クラスに関数の使用特性と機能を持たせることである.
シミュレーション関数はC言語とC++で実現でき,C言語のシミュレーション関数は関数ポインタとコールバック関数を用いて実現される.
まず、C言語の実装を見てみましょう.
#include <stdio.h>  
#include <stdlib.h>  
//int sort_function( const void *a, const void *b);  
int sort_function( const void *a, const void *b)  
{     
    return *(int*)a-*(int*)b;  
}  
  
int main()  
{  
     
   int list[5] = { 54, 21, 11, 67, 22 };  
   qsort((void *)list, 5, sizeof(list[0]), sort_function);//    ，  ，    ，       
   int  x;  
   for (x = 0; x < 5; x++)  
          printf("%i
", list[x]);  
                    
   return 0;  
}

そしてC++は簡単になり、具体的な呼び出しは例を挙げて、等しいかどうかを判断するシミュレーション関数を実現します.
template<class T>
struct A
{
	bool operator()(const T& a,const T& b)
	{
		return (a == b);
	}
};

int main()
{
	A<int>a;
	cout << a(1, 2) << endl;
	system("pause");
	return 0;
}

これは最も簡単な模倣関数で、皆さんは大体この模倣関数がどのように使われているか知っているでしょう.
スマートポインタでshared_を実現しましたptrの簡単な実装では、コードを見てみましょう.
template<class T>
class shared
{
public:
	shared(T* ptr)
		:_ptr(ptr)
		, _num(new int(1))
	{
	}
	shared(const shared<T>& ap)
		:_ptr(ap._ptr)
		, _num(ap._num)
	{
		++(*_num);
	}
	shared<T>& operator=(const shared<T>& ap)
	{
		if (_ptr != ap._ptr)
		{
			Release();
			_ptr = ap._ptr;
			_num = ap._num;
			++(*_num);
		}
		return *this;
	}
	T* operator->()
	{
		return _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}
	void Release()
	{
		if (0 == (--*_num))
		{
			cout << "             " << endl;
			delete _ptr;
			delete _num;
			_ptr = NULL;
			_num = NULL;
		}
	}
	~shared()
	{
		Release();
	}
protected:
	T* _ptr;
	int* _num;
};

しかし、スマートポインタでどんなオブジェクトを指してもdeleteで解放されるという問題があります.これは明らかにできません.
開発スペースはnewだけでなくnew[],malloc...この実装は少し簡単ですが、シミュレーション関数を使用しています.
この問題を解決してみてください.
ここでは、空間を解放するときに数を数えるので、テンプレートとシミュレーション関数を結びつけることができます.
(deleteを使用するかdelete[]を使用するか)はクラス外から伝達されるので,内部でdeleteを使用して空間を解放することを事前にそれぞれ実現することができる.
とdelete[]を使用して空間のシミュレーション関数を解放し、そのクラスをテンプレートから呼び出し、ターゲットクラス内でオブジェクトを作成し、オブジェクトの
擬似関数
//  delete        
template<class T>
class Delete
{
public:
	Delete()
	{}
	void operator()(T* _ptr)
	{
		cout << "delete" << endl;
		delete _ptr;
		_ptr = NULL;
	}
	~Delete()
	{}
protected:
	T* _ptr;
};


//  delete[]        
template<class T>
class DeleteArray
{
public:
	DeleteArray()
	{}
	void operator()(T* _ptr)
	{
		cout << "delete[]" << endl;
		delete[] _ptr;
		_ptr = NULL;
	}
	~DeleteArray()
	{}

};

template>
テンプレートは、テンプレートのデフォルト属性がdeleteのために空間を解放し、構造関数をこのように設計することができます.
inline void Release()
	{
		if (0 == (--*_num))
		{
			delete _num;
			_num = NULL;
			Del _del;
			_del(_ptr);
		}
	}
	~shared()
	{
		Release();
	}

Delオブジェクトを作成します.ここで私たちのDelはDeleteのように、私たちの_del(_ptr)の内部は、deleteで解放されます
_ptr、だから私たちはこのようにテンプレートと模倣関数を結びつけて、私は1枚の図を描いて私たちに理解してもらいましょう.
私达は今ゆっくりと関数の使い方をまねて本当にとても多くて、同じくとても柔軟で、私达は今ただ彼を知っているだけで、それでは
出てきたときにこれがどのように使われているかを知っていて、普段は模倣関数を適用すると想像できない楽しみと便利さをもたらすかもしれません.
模関数とテンプレートはよく一緒にパートナーになることができます.覚えておいてください.だから、彼二人ともマスターしなければなりません.
FPGA実践教程(七)IPcoreを用いてDDRを呼び出す
2020年のベストコラボレーションツール（トップ10レビュー）