C++副本构造器赋值不会

过默

1. #include <iostream>
   
2. #include <string>
   
3. 
   
4. class MyClass
   
5. {
   
6. public:
   
7. MyClass(int *p);
   
8. MyClass(const MyClass &rhs);
   
9. ~MyClass();
   
10. 
    
11. MyClass &operator=(const MyClass &rhs);
    
12. void print();
    
13. private:
    
14. int *ptr;
    
15. };
    
16. 
    
17. MyClass::MyClass(int *p)
    
18. {
    
19. std::cout << "进入主构造器\n";
    
20. ptr = p;
    
21. std::cout << "离开主构造器\n";
    
22. }
    
23. 
    
24. MyClass::MyClass(const MyClass &rhs)
    
25. {
    
26. std::cout << "进入副本构造器\n";
    
27. *this = rhs;
    
28. std::cout << "离开副本构造器\n";
    
29. }
    
30. 
    
31. MyClass::~MyClass()
    
32. {
    
33. std::cout << "进入析构器\n";
    
34. delete ptr;
    
35. std::cout << "离开析构器\n";
    
36. }
    
37. 
    
38. MyClass &MyClass::operator=(const MyClass &rhs)
    
39. {
    
40. std::cout << "进入赋值语句重载\n";
    
41. if( this != &rhs )
    
42. {
    
43. delete ptr;
    
44. 
    
45. ptr = new int;
    
46. *ptr = *rhs.ptr;
    
47. }
    
48. else
    
49. {
    
50. std::cout << "赋值号两边为同个对象，不做处理！\n"; // obj1 = obj1;
    
51. }
    
52. 
    
53. std::cout << "离开赋值语句重载\n";
    
54. 
    
55. return *this;
    
56. }
    
57. 
    
58. void MyClass::print()
    
59. {
    
60. std::cout << *ptr << std::endl;
    
61. }
    
62. 
    
63. int main()
    
64. {
    
65. MyClass obj1(new int(1));
    
66. MyClass obj2(new int(2));
    
67. obj2 = obj1;
    
68. obj1.print();
    
69. obj2.print();
    
70. 
    
71. std::cout << "-------------------------------\n";
    
72. 
    
73. MyClass obj3(new int(3));
    
74. MyClass obj4 = obj3;
    
75. obj3.print();
    
76. obj4.print();
    
77. 
    
78. std::cout << "-------------------------------\n";
    
79. 
    
80. MyClass obj5(new int(5));
    
81. obj5 = obj5;
    
82. obj5.print();
    
83. 
    
84. return 0;
    
85. }
    

复制代码

#include <iostream>
#include <string>
class MyClass
{
public:
    MyClass(int *p);
    MyClass(const MyClass &rhs);
    ~MyClass();
    MyClass &operator=(const MyClass &rhs);
    void print();
private:
    int *ptr;
};
MyClass::MyClass(int *p)
{
    std::cout << "进入主构造器\n";
    ptr = p;
    std::cout << "离开主构造器\n";
}
MyClass::MyClass(const MyClass &rhs)
{
    std::cout << "进入副本构造器\n";
    *this = rhs;
    std::cout << "离开副本构造器\n";
}
MyClass::~MyClass()
{
    std::cout << "进入析构器\n";
    delete ptr;
    std::cout << "离开析构器\n";
}
MyClass &MyClass :: operator=(const MyClass &rhs)
{
    std::cout << "进入赋值语句重载\n";
    if( this != &rhs )
    {
        delete ptr;
        ptr = new int;
        *ptr = *rhs.ptr;
    }
    else
    {
        std::cout << "赋值号两边为同个对象，不做处理！\n"; // obj1 = obj1;
    }
    std::cout << "离开赋值语句重载\n";
    return *this;
}
void MyClass::print()
{
    std::cout << *ptr << std::endl;
}
int main()
{
    MyClass obj1(new int(1));
    MyClass obj2(new int(2));
    obj2 = obj1;
    obj1.print();
    obj2.print();
    std::cout << "-------------------------------\n";
    MyClass obj3(new int(3));
    MyClass obj4 = obj3;
    obj3.print();
    obj4.print();
    std::cout << "-------------------------------\n";
    MyClass obj5(new int(5));
    obj5 = obj5;
    obj5.print();
    return 0;
}

这句什么意思const MyClass &rhs                 如何赋值语句重载MyClass &MyClass :: operator=(const MyClass &rhs)   this 与 *this有区别吗？  这句也不懂*ptr = *rhs.ptr;

MyClass::MyClass(int *p)
{
    std::cout << "进入主构造器\n";
    ptr = p;
    std::cout << "离开主构造器\n";
}
MyClass::MyClass(const MyClass &rhs)
{
    std::cout << "进入副本构造器\n";
    *this = rhs;
    std::cout << "离开副本构造器\n";
}

    MyClass obj1(new int(1));
    MyClass obj2(new int(2));
    obj2 = obj1;
    obj1.print();
    obj2.print();
    std::cout << "-------------------------------\n";
    MyClass obj3(new int(3));
    MyClass obj4 = obj3;
    obj3.print();
    obj4.print();
    std::cout << "-------------------------------\n";
obj2 = obj1;
myClass obj4 = obj3;       赋值对象，打印的主构造器与副本构造器不一样。是什么判断出来的？

洛川子

我只是路过打酱油的。我真的很感悟……