1
 P a = P(10); //这是拷贝构造。因为a还不存在。
2
//------------------------------------------------------
3
 P a;
4
 a =  P(10); //这是拷贝赋值。因为a已经存在了

1
P p1(p2); //使用一个对象给另一个对象初始化

1
P p1 = p2; //使用一个对象给另一个对象初始化
2
P p1 = P(10);//使用一个临时对象给另一个对象初始化
3
P* p1 = new P(10); //指针也不例外 这种声明使用10初始化一个匿名对象，并将新对象的地址赋给p1指针。

1
class Person
2
{
3
public:
4
  Person(){}
5
  Person(const Person& p)
6
  {
7
    cout << "Copy Constructor" << endl;
8
  }
9

10
  Person& operator=(const Person& p)
11
  {
12
    cout << "Assign" << endl;
13
    return *this;
14
  }
15

16
private:
17
  int age;
18
  string name;
19
};
20

21
void f(Person p)
22
{
23
  return;
24
}
25

26
Person f1()
27
{
28
  Person p;
29
  return p;
30
}
31

32
int main()
33
{
34
  Person p;
35
  Person p1 = p;    // 1
36
  Person p2;
37
  p2 = p;           // 2
38
  f(p2);            // 3
39

40
  p2 = f1();        // 4
41

42
  Person p3 = f1(); // 5
43

44
  getchar();
45
  return 0;
46
}

1
"Copy Constructor"   //1
2

3
"Assign"      //2
4

5
"Copy Constructor"  //3
6

7
"Copy Constructor"   //4
8
"Assign"
9

10
"Copy Constructor"   //5

1
class A {
2
    public:
3
        A(){}
4
        A(int a) :m_a(a) {}
5
        virtual~A(){}
6
        A& operator=(const A& rhs) {
7
            m_a = rhs.m_a;
8
            return *this;
9
        }
10
  int m_a;
11
};
12

13
class B : public A{
14
    public:
15
        B(){}
16
        B(int x):m_b(x){}
17
        B(int no, int x):A(no),m_b(x){} //这里用到了子类调用父类构造
18
        ~B(){}
19

20
        B& operator=(const B& rhs) {
21
            this->A::operator=(rhs); //这里是函数调用。
22
            /*
23
            我们函数调用可以不接受返回值。operator=的返回值的目的是返回一个自己用来进行下一步操作。是为了满足链式调用。当然也可以啥也不返回。
24
            所以隔壁的拷贝构造就没返回值。
25
            但是我们子类调用父类的拷贝赋值仅仅是把子类的父类部分调用父类的拷贝赋值来进行一个赋值。
26
            这里的例子就是子类的父类部分m_a使用父类的拷贝赋值给copy一遍。
27
            然后我们直接调用完了父类的拷贝赋值后，再自己赋值子类部分。
28
            时刻谨记 b1 = b2 就是b1.operator=(b2);
29
            */
30
            m_b = rhs.m_b;
31
            return *this;
32

33
        }
34
        int m_b;
35
};
36

37
int main(){
38
    B b(5,8);
39
    cout << b.m_a << endl;
40

41
    return 0;
42
}

1
class myobj{
2
    public:
3
        myobj(int x):val(new int(x)){ //构造
4
            cout <<"const" << endl;
5
        }
6
        myobj(const myobj& obj){ //拷贝构造
7
            cout <<"copy const" << endl;
8
            val = new int(*obj.val);
9
        }
10
        myobj& operator=(const myobj & rhs){ //拷贝赋值
11
            cout <<"copy= const" << endl;
12
            if(this == &rhs){
13
                return *this;
14
            }
15
            delete this->val;
16
            val = new int(*rhs.val);
17
            return *this;
18
        }
19

20
        myobj(myobj&& obj){ //移动构造
21
            cout <<"mv" << endl;
22
            val = obj.val;
23
            obj.val = new int(3939);
24
        }
25
        myobj& operator=(myobj&& rhs){ //移动赋值
26
            cout <<"mv=" << endl;
27
            if(this == &rhs){
28
                return *this;
29
            }
30
            if(this->val != nullptr){
31
                delete val;
32
            }
33
            val = rhs.val;
34
            rhs.val = nullptr;
35
            return *this;
36

37
        }
38
        ~myobj(){
39
            cout <<"dest" << endl;
40
            delete val;
41
            val = nullptr;
42
        }
43

44
        int* val;
45

46
};

1
class testobj{
2
    public:
3
    myobj inner;
4
    testobj(myobj obj):inner(move(obj)){} //版本1 值传递
5
};
6

7

8

9
int main(){
10
    myobj temp(20);
11
    testobj out(temp);
12
    cout << *temp.val << endl; //输出什么？
13
    return 0;
14
}

1
const //构造temp对象
2
copy const //值传递导致的拷贝至构造函数中。
3
mv //构造函数中使用move把拷贝的对象转换为右值然后移动构造的inner
4
dest//拷贝进来的参数析构
5
20
6
dest //testobj里的myobj析构
7
dest//外部myobj析构

1
class testobj{
2
    public:
3
    myobj inner;
4
    testobj(myobj obj):inner(move(obj)){} //版本1 值传递
5
};
6

7

8

9
int main(){
10
    myobj temp(20);
11
    testobj out(move(temp)); //这里我们也用move
12
    return 0;
13
}

1
const //构造temp对象
2
mv //右值触发移动构造传入函数参数
3
mv //右值触发移动构造从函数入参构建inner
4
dest
5
dest
6
dest

1
class testobj{
2
    public:
3
    myobj inner;
4
    testobj(myobj& obj):inner(move(obj)){} //左值引用
5
};
6

7

8

9
int main(){
10
    myobj temp(20);
11
    testobj out(temp);
12
    //testobj out(myobj(20)); 不行。
13
    cout << *temp.val << endl;
14
    return 0;
15
}

1
const //temp对象构建
2
mv //引用传递不发生拷贝，这里的move变成右值的是temp对象本身。所以触发移动构造testobj内的inner
3
3939 //外部对象已经被移动。输出3939
4
dest
5
dest

1
class testobj{
2
    public:
3
    myobj inner;
4
    testobj(const myobj& obj):inner(move(obj)){} //常量左值引用
5
};
6

7

8

9
int main(){
10
    myobj temp(20);
11
    testobj out(temp);
12
    cout << *temp.val << endl;
13
    return 0;
14
}

1
const //temp对象构建
2
copy const //引用传递不发生拷贝。这里的拷贝是从构造函数入参中拷贝至myobj的inner对象。
3
20//外部不移动
4
dest
5
dest

1
class testobj{
2
    public:
3
    myobj inner;
4
    testobj(myobj&& obj):inner(move(obj)){} //右值引用
5
};
6

7

8

9
int main(){
10
    myobj temp(20);
11
    testobj out(move(temp)); //move换成右值
12
    cout << *temp.val << endl;
13
    return 0;
14
}

1
const //构造temp
2
mv //引用传递不拷贝。这个move是把temp对象转换为右值后触发拷贝构造
3
3939//temp已被移动。
4
dest
5
dest

1
testobj out(myobj(10));
2

3

4
const //构造临时对象。临时对象必须得有啊不然传的是啥？
5
mv //move把临时对象换成右值，触发移动构造。
6
dest
7
dest

1
template <typename T>
2
class testobj{
3
    public:
4
    T inner;
5
    testobj(T&& obj) : inner(forward<T>(obj)){} // cannot bind rvalue reference of type ‘myobj&&’ to lvalue of type ‘myobj’
6
};
7
int main(){
8
    myobj var(10);
9
    testobj<myobj> a(var); //cannot bind rvalue reference of type ‘myobj&&’ to lvalue of type ‘myobj’
10
}

1
class testobj{
2
    public:
3
    myobj inner;
4
    template <typename Arg>
5
    testobj(Arg&& obj):inner(forward<Arg>(obj)){}
6
};

1
class testobj{
2
    public:
3
    myobj inner;
4
    //testobj(myobj&& obj):inner(move(obj)){}
5
    testobj(myobj&& obj):inner((obj)){} //我们这里不使用move
6
};

1
testobj our(myobj(10));
2
const //构造临时对象
3
copy const //哇哦，发生了拷贝。
4
dest
5
dest

1
void func(myobj&& rhs){
2
    //这里rhs是具名右值引用。是左值。所以如果这时候有函数接受左值或右值引用形式的rhs，则会匹配至左值
3
}

1
class testobj{
2
    public:
3
    myobj inner;
4
    testobj(myobj&& obj):inner(move(obj)){}//使用move
5
};

1
class testobj{
2
    public:
3
    myobj inner;
4
    template <typename Arg>
5
    testobj(Arg&& obj):inner(forward<Arg>(obj)){} //使用forward
6
};

1
class ano{
2
    public:
3
        myobj val;
4
        ano(myobj ano):val(move(ano)){}; // 注意此时入参是值传递而不是右值引用。
5
};
6
int main(){
7
    myobj a(20);
8
    ano pro(move(a));
9
    return 0;
10
}