template<typename T>
void passByRefFun(T& val) { }

template<typename T>
void passByUniRefFun(T&& val) { }

template<typename T>
void passByValueFun(T val) { }

void fun3(int& a) { }
void fun3(int&& a) { }

void test()
{
    int a = 0;          //a int
    const int b = a;    //b const int
    const int& c = a;   //c const int&
    
    passByRefFun(a);    // int&
    passByRefFun(b);    // const int&
    passByRefFun(c);    // const int&
    //passByRefFun(27);   // 报错
    
    passByUniRefFun(a); // int&
    passByUniRefFun(b); // const int&
    passByUniRefFun(c); // const int&
    passByUniRefFun(27); // int&&
    
    passByValueFun(a);  // int
    passByValueFun(b);  // int
    passByValueFun(c);  // int
    passByValueFun(27); // int
    
    {
        int&& a = 10;
        fun3(a);            // called void fun3(int& a)
        fun3(std::move(a)); // called void fun3(int&& a)
        
    }
}

#include <iostream>
using namespace std;

//终止函数
int multiply()
{
    return 1;
}

//递归展开
template <typename T, typename ...Args>
int multiply(T&& t, Args&& ...arg)
{
    return t * multiply(arg...);
}

int main(int argc, const char * argv[]) {
    
    cout << multiply(3, 4, 5) << endl;
    
    cout << multiply() << endl;
    
    return 0;
}

template<class F, class... Args>void expand(const F& f, Args&&...args)
{
  //这里用到了完美转发，关于完美转发，读者可以参考笔者在上一期程序员中的文章《通过4行代码看右值引用》
  initializer_list<int>{(f(std::forward< Args>(args)),0)...};
}

int main(int argc, const char * argv[]) {
    
    expand([](int i) {
        cout<<i<<endl;
    }, 1,2,3);
    return 0;
}

struct myclass {
    myclass(int,int)
    {
        cout << "myclass constructor" << endl;
    }
    myclass(initializer_list<int>)
    {
        cout << "myclass initializer_list constructor" << endl;
    }
};


int main(int argc, const char * argv[]) {
    
    auto il = {10, 20, 30};
    
    myclass foo {10,20};  // calls initializer_list constructor
    myclass bar (10,20);  // calls first constructo
    
    return 0;
}

template <typename T>
void Add(T&& a, T&& b) {
    cout << a << endl;
    cout << b << endl;
}

int main() {
    
    Add(4, 5); // a，b的类型会被推导成int&&
    int a = 0;
    int b = 0;
    Add(a, b); // a，b的类型会被推导成int&
    
    return 0;
}

template <typename T>
void AddImp(T&& a, T&& b) {
    cout << a << endl;
    cout << b << endl;
}

template <typename T>
void Add(T&& a, T&& b) {
    AddImp(a, b);
}

int main() {
    
    Add(4, 5);
    int a = 0;
    int b = 0;
    Add(a, b);
    
    return 0;
}

template <typename T>
void Add(T&& a, T&& b) {
    AddImp(std::forward<T>(a), std::forward<T>(b));
}

template <class _Tp>
_Tp&& forward(typename remove_reference<_Tp>::type& __t) 
{
  return static_cast<_Tp&&>(__t);
}

int main()
{
    shared_ptr<Person> person1;
    
    shared_ptr<Person> person2(nullptr);
    
    shared_ptr<Person> person3(new Person(10));

    shared_ptr<Person> person4 = std::make_shared<Person>(5); //效率更高，内存分布在一起
    
    shared_ptr<Person> person5(std::move(person3)); // person3无法再使用
    
    shared_ptr<Person> arary(new Person[10], deletePersonArray);
    
    weak_ptr<Person> weak_Person = person5;
    
    cout << weak_Person.use_count() << endl;
    
    shared_ptr<Person> person6 = person5;
    
    cout << weak_Person.use_count() << endl;
    
    person5.reset();
    
    cout << weak_Person.use_count() << endl;
    
    person6.reset();
    
    if (weak_Person.expired()) {
        cout << weak_Person.use_count() << endl;
        
        auto shareptr = weak_Person.lock();
        
        cout << shareptr << endl;
    }
    
    return 0;
    
}

int main() {
    
    int a = 0; //ok
    
    int& b = a; //ok,左值引用
    int& c = 0; // not ok,左值引用无法引用右值
    
    const int& d = 0; // ok，常左值引用，可以绑定右值
    const int& e = a; // ok，常左值引用，可以绑定左值
    
    int&& f = 0;//ok 右值引用绑定右值
    const int && g = 0; // ok,常右值引用可以绑定右值
    //但是实际上没有意义，因为绑定的右值无法修改，一般右值引用是为了实现移动语义，降低copy消耗
    
    int&& h = a;//not ok，右值引用无法绑定左值
    
    return 0;
}

Person GetPerson(){
    return Person();
}

int main()
{
    Person person = GetPerson();
    person.print();
    
    /*
     一共执行三次构造
    1 Person()默认构造函数
    2 GetPerson函数返回时，生成临时对象，调用移动构造函数
    3 使用临时对象，构造person，调用移动构造函数
     */
    return 0;
}

Person&& GetPerson(){
    return Person();
}

int main()
{
    Person person = GetPerson();
    person.print();
    
    /*
     一共执行两次次构造，这种写法是错的，会有warnning
     Returning reference to local temporary object
    1 Person()默认构造函数
    2 右值引用，引用了已经析构的临时对象
    3 使用临时对象，构造person，调用移动构造函数
     */
    return 0;
}

Person GetPerson(){
    return Person();
}

int main() {
    
    Person person1 = GetPerson(); //调用一次构造，两次次移动构造
    
    Person&& person2 = GetPerson(); //调用一次构造，一次移动构造
    
    return 0;
}

const Person& GetPerson1(){
    return Person();
}

Person&& GetPerson2(){
    return Person();
}