首先说明一下仿指针与仿函数是什么，指针我们知道是一个地址，我们可以利用指针来访问它所指向的value，仿指针就是用一个类去实现指针的作用，那么我们为什么要特地写一个类去实现指针呢，因为在我们开发过程中，我们希望指针可以有更多功能，而不仅仅是指向一个地址，那么我们就可以通过一个类去实现指针的功能的前提下，给它加上更多的功能，来满足我们的需求，比如说我们每使用一次指针，都要去释放掉这个指针，如果忘记释放，就会造成内存泄露，但我们无法使指针自己释放，但是如果是指针类，我们就可以在析构函数中加上delete语句，那么以后使用这个指针，就再也不用管它的释放问题了，C++特性中的智能指针其实就是这种原理，仿函数也是类似道理。

 

_ pointer-like classes

简单用代码实现一个智能指针，其实就是老版本的shared_ptr指针，可以明白其中的运作原理

#include<iostream>
using namespace std;

template<class T>
class shared_ptrc 
{
public:
    T& operator*() const
    {
        return *px;
    } 
    T* operator->() const
    {
        return px;
    }

    shared_ptrc(T* p) : px(p){}
    ~shared_ptrc() { delete px; }
private:
    T*      px;
    long* pn;
};

struct Foo
{
    void method() { cout << "Foo::method" << endl; }
};

int main() {
    shared_ptrc<Foo> sp(new Foo);
    Foo f(*sp);

    sp->method();
    system("pause");
    return 0;
}

 

首先从它的重载说起， 可以看到

    T& operator*() const
    {
        return *px;
    } 

 

重载了*号，并且无参数，这样就符合了指针的语法，我们平常建立一个指针比如int * p;  *p代表就是它所指的value,再看这里，返回 *px,而px又是T类的指针(T * px),所以这里就是返回一个value，并且函数开头是T&,

之前说了返回value的reference比直接返回value普遍要快很多，所以这里返回了一个reference。

我们再看

 T* operator->() const
    {
        return px;
    }

当我们使用"->"时，是不是一般都是调用指针所指内容的方法或者属性，所以我们必须要返回指针类型，所以这里是 T* operator->() ,（如果这里不明白可以看之前说的引用与指针的区别）

所以现在来看，我们是不是就可以把shared_ptrc当作一个指针类型来使用了

 shared_ptrc<Foo> sp(new Foo);

这样就是导入Foo模板，并且new一个Foo类对象，让shared_ptrc类中的px指针指向它，然后当我们使用完这个指针后，程序结束后，它会调用析构函数自动销毁，无需手动释放，这就是仿指针的基本用法。

迭代器其实也是一种仿指针，平常使用迭代器我们都有接触过，比如创建一个vector数组的迭代器，vector<int>::iterator it;我们经常会使用这种语法 it++,++it,使迭代器指针指向数组中的下一个内容，这其实就是在指针类中重载了++符号来实现的。

 

为了更加了解仿指针，我们可以看一看C++的智能指针，这样也能使我们对使用指针的风险更加了解。

有4种智能指针：auto_ptr(C++11已弃用), unique_ptr,shared_ptr, weak_ptr 

首先看看智能指针为我们解决的问题，其实跟上面所说的基本一样。

当我们使用普通指针时：

void func(string & str)
{
    ...
    string * s = new string(str);
    if (error())
        throw exception();
    str = *s; 
    delete s;
    ...
    return;
}

 

当程序出错，抛出异常，可以很明显看到发生了一个严重的问题，s指针未被释放，程序就中止了，导致内存泄露。

而我们如果使用智能指针auto_ptr

void func(string & str)
{
    ...
    auto_ptr<string> s(new string(str));
    if (error())
        throw exception();
    str = *s; 
    ...
    return;
}

 

程序抛出异常，auto_ptr会调用内部析构函数，释放掉指针，这样就避免了内存泄漏。

然后说一下为什么auto_ptr会被抛弃，auto_ptr的工作模式是拥有所有权。对于特定的对象，只能有一个智能指针可拥有，这样只有拥有对象的智能指针的析构函数会删除该对象。赋值操作会转让所有权。

可以看下面这一串代码：

#include <iostream>
#include <string>
using namespace std;

int main() {
  auto_ptr<string> test[3] =
 {
  auto_ptr<string> (new string("helloworld1")),
  auto_ptr<string> (new string("helloworld2")),
  auto_ptr<string> (new string("helloworld3")),
 };
 auto_ptr<string> p;
 p = test[2]; // test[2]所有权被p拿走，此时test[2]为一个空指针。

 cout<<test[2]<<endl; //运行时报错

 return 0;
}

可以看出auto_ptr存在内存泄漏的潜在风险，所以不再使用auto_ptr，unique_ptr也是所有权模式，但是如果将上面auto_ptr换成unique_ptr的话，不会在运行程序时报错，而是会在编译时报错，这样也可以避免内存泄漏的潜在风险。

 

shared_ptr与weak_ptr则是另外一种模式，这里就不详细说明了，以后专门再用一篇博客描述4种智能指针。

 

_ function-like classes

仿函数也是用一个模板类去实现的，实现原理与仿指针差不多，由于目前不经常使用，了解不是很深，就先把代码语法问题解决了，以后再补充说明仿函数的使用环境与时机。

template <class T>
struct identity{
    const T&
    operator() (const T& x) const {return x;}
};

template <class Pair>
struct select1st   {
    const typename Pair::first_type&
    operator() (const Pair& x) const
    { return x.first;}
};

template <class Pair>
struct select2nd  {
    const typename Pair::second_type&
    operator() (const Pair& x) const
    { return x.second;}
};

template <class T1,class T2>
struct pair{
    T1 first;
    T2 second;
    pair() : first(T1()),second(T2()){}
    pair(const T1& a, const T2& b)
        : first(a),second(b) {}
...
};

 

可以看到select1st与select2nd可以当作函数来使用，分别返回pair的两个value。