C++: “仿函数” 与 “定置删除器”

本文主要是介绍C++: “仿函数” 与 “定置删除器”，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

写在前面：

之前在总结c++智能指针的时候提到过这么一个问题：对于shared_ptr，如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题。

//仿函数的删除器template<class T>struct FreeFunc {void operator()(T* ptr){cout << "free:" << ptr << endl;free(ptr);}
};template<class T>struct DeleteArrayFunc {void operator()(T* ptr){ cout << "delete[]" << ptr << endl;delete[] ptr; }
};int main()
{FreeFunc<int> freeFunc;shared_ptr<int> sp1((int*)malloc(4), freeFunc);DeleteArrayFunc<int> deleteArrayFunc;shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);return 0;

1.认识仿函数

先来看仿函数的通俗定义：仿函数（functor）又称为函数对象（function object）是一个能行使函数功能的类。仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载operator()运算符，举个例子：

class Func{public:void operator() (const string& str) const {cout<<str<<endl;}
};int main(){Func myFunc;myFunc("helloworld!");}
//运行结果    >>>helloworld!

2.定置删除器

简单的实现一个有定置删除器的shared_ptr

struct Fclose
{void operator()(void *ptr){fclose((FILE *)ptr);cout << "fclose()" << endl;}
};struct Free
{void operator()(void *ptr){free(ptr);cout << "free()" <<endl;}
};//默认删除器是delete
struct DefaultDel
{void operator()(void* ptr){delete ptr;cout << "delete ptr" << endl;}
};
template<typename T, typename D = DefaultDel>
class SharedPtr          //采用引用计数，实现一个可以有多个指针//指向同一块内存的类模板，SharedPtr是类模板，不是智能指针类型
{
public:SharedPtr(T* ptr, D del = DefaultDel());SharedPtr(const SharedPtr<T,D>& sp);SharedPtr<T,D>& operator=(SharedPtr<T,D> sp);T& operator*();T* operator->();~SharedPtr();int Count(){return *_pCount;}
private:void Release(){if (--(*_pCount) == 0){_del(_ptr);delete _pCount;_ptr = NULL;_pCount = NULL;}}
private:T* _ptr;int* _pCount;D _del;
};
//构造函数
template<typename T, typename D = DefaultDel>
SharedPtr<T,D>::SharedPtr(T* ptr,D del)
:_ptr(ptr)
, _pCount(new int(1))
,_del(del){}{}//拷贝构造函数
template<typename T, typename D = DefaultDel>
SharedPtr<T,D>::SharedPtr(const SharedPtr<T,D>& sp)
{_ptr = sp._ptr;_pCount= sp._pCount;++(*_pCount);
}//operator=	
template<typename T, typename D = DefaultDel>
SharedPtr<T,D>& SharedPtr<T,D>::operator=(SharedPtr<T,D> sp)
{std::swap(sp._ptr,_ptr);std::swap(sp._pCount,_pCount);return *this;
}//operator *
template<typename T, typename D = DefaultDel>
T& SharedPtr<T,D>::operator*()
{return *_ptr;
}//operator ->
template<typename T, typename D = DefaultDel>
T* SharedPtr<T,D>::operator->()
{return _ptr;
}//析构函数
template<typename T, typename D = DefaultDel>
SharedPtr<T,D>::~SharedPtr()
{Release();
}//测试用例
void test()
{SharedPtr<int> sp(new int(1));SharedPtr<FILE,Fclose> sp1(fopen("test.txt","w"),Fclose());SharedPtr<string,Free> sp3((string *)malloc(sizeof(string)),Free());
}int main()
{test();system("pause");return 0;}

这篇关于C++: “仿函数” 与 “定置删除器”的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---