1 #include <iostream>
  2 #include <assert.h>
  3 
  4 class MyClass
  5 {
  6 public:
  7     MyClass(const char * str = nullptr);  // 默认带参构造函数
  8     ~MyClass(void);  // 默认析构函数
  9     MyClass(const MyClass &);  // 默认拷贝构造函数
 10     MyClass & operator =(const MyClass &);  // 默认重载赋值运算符函数
 11     MyClass * operator &();  // 默认重载取址运算符函数
 12     MyClass const * operator &() const;  // 默认重载取址运算符const函数
 13     MyClass(MyClass &&);  // 默认移动构造函数
 14     MyClass & operator =(MyClass &&);  // 默认重载移动赋值操作符函数
 15 
 16 private:
 17     char *m_pData;
 18 };
 19 
 20 // 默认带参构造函数
 21 MyClass::MyClass(const char * str)
 22 {
 23     if (!str)
 24     {
 25         m_pData = nullptr;
 26     } 
 27     else
 28     {
 29         this->m_pData = new char[strlen(str) + 1];
 30         strcpy(this->m_pData, str);
 31     }
 32     std::cout << "默认带参构造函数" << std::endl;
 33 }
 34 
 35  // 默认析构函数
 36 MyClass::~MyClass(void)
 37 {
 38     if (this->m_pData)
 39     {
 40         delete[] this->m_pData;
 41         this->m_pData = nullptr;
 42     }
 43     std::cout << "默认析构函数" << std::endl;
 44 }
 45 
 46 // 默认拷贝构造函数
 47 MyClass::MyClass(const MyClass &m)
 48 {
 49     if (!m.m_pData)
 50     {
 51         this->m_pData = nullptr;
 52     } 
 53     else
 54     {
 55         this->m_pData = new char[strlen(m.m_pData) + 1];
 56         strcpy(this->m_pData, m.m_pData);
 57     }
 58     std::cout << "默认拷贝构造函数" << std::endl;
 59 }
 60 
 61 // 默认重载赋值运算符函数
 62 MyClass & MyClass::operator =(const MyClass &m)
 63 {
 64     if (this != &m)
 65     {
 66         delete[] this->m_pData;
 67         if (!m.m_pData)
 68         {
 69             this->m_pData = nullptr;
 70         } 
 71         else
 72         {
 73             this->m_pData = new char[strlen(m.m_pData) + 1];
 74             strcpy(this->m_pData, m.m_pData);
 75         }
 76     }
 77     std::cout << "默认重载赋值运算符函数" << std::endl;
 78     return *this;
 79 }
 80 
 81 // 默认重载取址运算符函数
 82 MyClass * MyClass::operator &()
 83 {
 84     std::cout << "默认重载取址运算符函数" << std::endl;
 85     return this;
 86 }
 87 
 88 // 默认重载取址运算符const函数
 89 MyClass const * MyClass::operator &() const
 90 {
 91     std::cout << "默认重载取址运算符const函数" << std::endl;
 92     return this;
 93 }
 94 
 95 // 默认移动构造函数
 96 MyClass::MyClass(MyClass && m):
 97     m_pData(std::move(m.m_pData))
 98 {
 99     std::cout << "默认重载取址运算符const函数" << std::endl;
100     m.m_pData = nullptr;
101 }
102 
103 // 默认重载移动赋值操作符函数
104 MyClass & MyClass::operator =(MyClass && m)
105 {
106     assert(this != &m);
107 
108     this->m_pData = nullptr;
109     this->m_pData = std::move(m.m_pData);
110     m.m_pData = nullptr;
111 
112     std::cout << "默认重载移动赋值操作符函数" << std::endl;
113     return *this;
114 }