类和对象中2-优快云博客

class Stack//对于栈这样的类，要自己写拷贝构造，如果用默认的，会进行浅拷贝
   //这样在析构的时候就会对一个资源释放两次，导致程序崩溃
   //如果一个类显式实现了析构，基本上就要显示实现拷贝构造
//class Date
//{
//public:
//   Date(int year = 1, int month = 1, int day = 1)
//   {
//       _year = year;
//       _month = month;
//       _day = day;
//   }
//   //传引用的时候，只要不想改变，就加上const
//   //Date(const Date& d)//这里用别名的话，就不会传参，也就不会形成拷贝构造
//   //{
//   //   _year = d._year;
//   //   _month = d._month;
//   //   _day = d._day;
//   //}
//   //对于类对象允许通过运算符重载重新定义运算符含义
//   //运算符重载不能创建新运算符，结合性与优先级不变
//   // .* :: sizeof ?: .以上五个运算符不能重载
//   //
//
//   //d1 = d2，d1给了this，d2是d
//   Date& operator= (const Date& d)//这里也可以传值，但最好传引用，可以减少拷贝
//   {
//       _year = d._year;
//       _month = d._month;
//       _day = d._day;
//
//       return *this;//*this就是d1，将d2赋值拷贝给d1，这就是用this的经典位置
//       //有返回值，且建议写成当前的类类型引用，以支持连续复制的场景
//   }
//
//   bool operator==(Date d2)//重载运算符至少有一个类类型参数
//   {
//       return _year == d2._year
//           && _month == d2._month
//           && _day == d2._day;
//   }
//   Date operator+(int day);
//   Date operator-(int day);
//   int operator-(const Date& d);
//   //这里operater==就是函数名，就和普通函数一样
//   //先去类里面找，如果类域没有，再去全局找
//   void Print()
//   {
//       cout << _year << '/' << _month << '/' << _day << endl;
//   }
//private:
//   int _year;
//   int _month;
//   int _day;
//};
//传引用返回可以减少拷贝，但是一定要确定返回对象在函数结束后还存在
//不然就是野引用；不穿引用的话，会产生一个临时对象，将要返回的拷贝过去
//再返回临时对象，这个临时对象不受函数生命周期影响
//int main()
//{
//   Stack s1, s2;//构造函数在实例化之后自动调用
//   //C++规定传值传参要调用拷贝构造
//
//   //自定义类型传参尽量传引用
//   Date d1;
//   d1.Print();
//   Date d2(d1);//拷贝构造
//   d2.Print();
//   //这里如果传值参的话，就会引发无穷递归，因为每次传参都要调用拷贝构造
//   //每次拷贝都要传参，而传参又要调用拷贝构造，最后就会因为没有结束条件而引发无穷递归
//   Date d3 = d1;//这种方式也是拷贝构造
//   return 0;
//}

//拷贝构造函数
// 第一个参数是自身类类型的引用，且任何额外的参数都有默认值
// 是构造函数的重载，使用传值方式会引发报错
// 若未显式定义拷贝构造，编译器会自动生成，会对内置类型成员变量也完成值拷贝‘
// 一个一个字节的拷贝，所以以上的Date是不需要自己写拷贝构造的
//

class A
{
public:
   void func()
   {
       cout << "A::func()" << endl;
   }
};
typedef void(A::*PF)();//成员函数指针类型
//int main()
//{
//   PF pf = nullptr;
//
//   //C++规定成员函数要加&才能取到函数指针
//   pf = &A::func;
//
//   A aa;
//   (aa.*pf)();// .* 运算符应用于成员函数的回调
//}

//int main()
//{
//   Date d1;
//   Date d2;
//   d1.operator==(d2);//运算符重载可以显示调用
//
//   d1 == d2;//编译器会转换成d1.operator(d2)
//
//   Date d3 = d2;//拷贝构造不是创建，是初始化，在主函数栈帧穿件的时候就已经创建了
//   d1 = d2;//这里是赋值运算符重载，是一种运算符重载，应用于已经存在的两个对象的拷贝复制
//   //而拷贝构造适用于一个对象拷贝初始化给另一个要创建的对象
//   //赋值运算符重载是要有返回值的
//   //没有显示定义，编译器会自动生成，重载行为跟默认拷贝构造类似，会完成浅拷贝，
//   // 对自定义类型会调用它的拷贝重载
//
//
//   //这里与拷贝构造一样，如果显式实现了析构（说明有资源释放），
//   // 那么也要显式实现赋值运算符重载
//   int i, j, k;
//   i = j = k = 1;//这里的结合性是从右往左
//   return 0;
//}