class MyString
{
public:
    ...
    //移动构造函数
    //参数是非const的右值引用
    MyString(MyString && t)
    {
        str = t.str; //拷贝地址，没有重新申请内存
        len = t.len;
        //原来指针置空，必须修改
        t.str = NULL;
        cout << "移动构造函数" << endl;
    }
    ...
private:
    char *str = NULL;
    int len = 0;
};

class MyString
{
public:
    ...
    //移动赋值函数
    //参数为非const的右值引用
    MyString &operator=(MyString &&tmp)
    {
        if(&tmp == this)
        {
            return *this;
        }
        //先释放原来的内存
        len = 0;
        delete [] str;
        //无需重新申请堆区空间
        len = tmp.len;
        str = tmp.str; //地址赋值
        tmp.str = NULL;
        cout << "移动赋值函数\n";
        return *this;
    }
   ...
private:
    char *str = NULL;
    int len = 0;
};

#include <iostream>
#include <memory>
using namespace std;
int main()
{
    unique_ptr<int> up1(new int(11));   // 无法复制的unique_ptr
    //unique_ptr<int> up2 = up1;        // err, 不能通过编译
    unique_ptr<int> up3 = move(up1);    // 现在p3是数据的唯一的unique_ptr
    up3.reset();            // 显式释放内存
    up1.reset();            // 不会导致运行时错误
    up4.reset(new int(44)); //"绑定"动态对象
    up4 = nullptr;//显式销毁所指对象，同时智能指针变为空指针。与up4.reset()等价
    unique_ptr<int> up5(new int(55));
    int *p = up5.release(); //只是释放控制权，不会释放内存
    delete p; //释放堆区资源
    return 0;
}

int main()
{
    shared_ptr<int> sp1(new int(22));
    shared_ptr<int> sp2 = sp1;
    cout << "count: " << sp2.use_count() << endl; //打印引用计数2
    sp1.reset();    //显式让引用计数减1
    cout << "count: " << sp2.use_count() << endl; //打印引用计数1
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;
class Son;
class Father {
public:
    shared_ptr<Son> son_;
    Father() {
        cout << __FUNCTION__ << endl;
    }
    ~Father() {
        cout << __FUNCTION__ << endl;
    }
};
class Son {
public:
    shared_ptr<Father> father_;
    Son() {
        cout << __FUNCTION__ << endl;
    }
    ~Son() {
        cout << __FUNCTION__ << endl;
    }
};
int main()
{
    auto son = make_shared<Son>();
    auto father = make_shared<Father>();
    son->father_ = father;
    father->son_ = son;
    cout << "son: " << son.use_count() << endl;
    cout << "father: " << father.use_count() << endl;
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;
int main()
{
    shared_ptr<int> sp1(new int(22));
    shared_ptr<int> sp2 = sp1;
    weak_ptr<int> wp = sp1; // 指向shared_ptr<int>所指对象
    cout << "count: " << wp.use_count() << endl; //打印计数器 2
    sp1.reset();
    cout << "count: " << wp.use_count() << endl; // 1
    sp2.reset();
    cout << "count: " << wp.use_count() << endl; // 0
    return 0;
}

class Son;
class Father {
public:
    SharedPtr<Son> son_;
    Father() {
        cout << __PRETTY_FUNCTION__ << endl;
    }
    ~Father() {
        cout << __PRETTY_FUNCTION__ << endl;
    }
};
class Son {
public:
    WeakPtr<Father> father_;  // 将SharedPtr改为WeakPtr
    Son() {
        cout << __PRETTY_FUNCTION__ << endl;
    }
    ~Son() {
        cout << __PRETTY_FUNCTION__ << endl;
    }
};
int main()
{
    auto son_ = new Son();  // 创建一个Son对象，返回指向Son对象的指针son_
    auto father_ = new Father();  // 创建一个Father对象，返回指向Father对象的指针father_
    SharedPtr<Son> son(son_);  // 调用SharedPtr构造函数：son.counter=1, son.weakref=0
    SharedPtr<Father> father(father_);  // 调用SharedPtr构造函数：father.counter=1, father.weakref=0
    son.resource->father_ = father;  // 调用WeakPtr赋值函数：father.counter=1, father.weakref=1
    father.resource->son_ = son;  // 调用SharedPtr赋值函数：son.counter=2, son.weakref=0
    cout << "son: " << son.use_count() << endl;
    cout << "father: " << father.use_count() << endl;
    return 0;
}

class MyFunctor
{
public:
    MyFunctor(int tmp) : round(tmp) {}
    int operator()(int tmp) { return tmp + round; }
private:
    int round;
};
int main()
{
    int round = 2;
    MyFunctor f(round);//调用构造函数
    cout << "result = " << f(1) << endl; //operator()(int tmp)
    return 0;
}

#include <iostream>
#include <functional>   //std::cout
using namespace std;
void func(void)
{//普通全局函数
    cout << __func__ << endl;
}
class Foo
{
public:
    static int foo_func(int a)
    {//类中静态函数
        cout << __func__ << "(" << a << ") ->: ";
        return a;
    }
};
class Bar
{
public:
    int operator()(int a)
    {//仿函数
        cout << __func__ << "(" << a << ") ->: ";
        return a;
    }
};
int main()
{
    //绑定一个普通函数
    function< void(void) > f1 = func;
    f1();
    //绑定类中的静态函数
    function< int(int) > f2 = Foo::foo_func;
    cout << f2(111) << endl;
    //绑定一个仿函数
    Bar obj;
    f2 = obj;
    cout << f2(222) << endl;
    /*
     运行结果：
        func
        foo_func(111) ->: 111
        operator()(222) ->: 222
    */
    return 0;
}