[陈宗权C++]C++第4天AM--静态成员函数_运算符重载_临

参考：

重点：

• 编译器会把运算符看成运算符函数
• 运算符函数的形参一定是引用的，尽量加const,要改变的加const
• 友元函数，允许这个函数访问这个类的私有成员
• 形参是等类类型的是拷贝构造函数
• 匿名对象，编译器优化，直接用创建临时对象的参数来创建1个新对象，不t2会调用复制构造函数
• 赋值，不会调复制构造函数，因为没有新对象，临时对象当场释放

正文：

////达内C++教程\03_标准C++编程_陈宗权_7day\标准C++编程_day04AM_静态成员函数_运算符重载_临时对象  TEST1
//
//#include<iostream>
//using namespace std;
//
////编译器会把运算符看成运算符函数
//// F a,b;
//// a+b;//看成a.operator+(b);或者operator+(a,b)
////运算符函数的形参一定是引用的，尽量加const,要改变的加const
//
//class fenshu {
//  int n;
//  int d;
//
//  void reduce() {}
//  friend ostream& operator<<(ostream& out, const fenshu& f1);
//
//public:
//  fenshu(int n = 0, int d = 1) :n(n), d(d)
//  {
//      if (d == 0) throw 0;
//      if (d < 0) d = -d, n = -n;
//      reduce();
//      std::cout << "fenshu" << n << "/" << d << "\n";
//  }
//
//  
//  // 静态成员函数，和对象没关系的函数,没有this
//  //  
//  static int maxcd(int a, int b) 
//  {
//      std::cout << a << "/" << b<< "\n";
//      return a;
//  }
//  //友元函数，允许这个函数访问这个类的私有成员
//  friend fenshu operator+(const fenshu& lh, const fenshu&rh) 
//  {
//      fenshu res(lh.n*rh.d + lh.d*rh.n, lh.d*rh.d);
//      return res;
//  }
//
//  //因为对象是临时的，所以不加引用
//  fenshu operator*(const fenshu& rh) const/*保证当前对象是可读的*/ 
//  {
//      /*fenshu res(n*rh.n,d*rh.d);
//      return res;*/                   //普通方式
//      return fenshu((n*rh.n, d*rh.d));//匿名对象
//  }
//  
//};
//// 用友元访问类的私有成员,他不是成员函数
//ostream& operator<<(ostream& out, const fenshu& f1)
//{
//  out << f1.d << ", " << f1.n;
//  return out;
//}
//
//int main()
//{
//  fenshu f1;
//  fenshu f2(12,1);
//  fenshu f3(12, 3);
//  std::cout <<f1<< f2;//operator<<(cout,f2);
//  
//  //不属于某个对象
//  fenshu::maxcd(1,2);
//  //f1+f2解过是个临时值，常量 得加const!!!!!!!!!!!!!!!!!!!!!!!!!!
//  std::cout << f1 + f2 +f3 << f1 + f3 << std::endl;
//  cout << f1*f2 << std::endl;//f1.operator*(f2);
//  system("pause");
//              
//}


////达内C++教程\03_标准C++编程_陈宗权_7day\标准C++编程_day04AM_静态成员函数_运算符重载_临时对象  TEST2

//形参是等类类型的是拷贝构造函数

#include <iostream>
#include <string>
using namespace std;

class Teacher {
    string name;
    string course;

public:
    Teacher(const char* n, const char* c) :name(n), course(c) {
        cout << "创建"<< course <<"老师"<<name<< endl;
    }
    Teacher(const Teacher& t) :name(t.name), course(t.course) {
        cout << "复制" << course << "老师" << name << endl;
    }

    ~Teacher() {
        cout << "辞退" << course << "老师" << name << endl;
    }


};

int main()
{
    Teacher t1("陈宗权","C++");
    Teacher t2 = t1;//初始化
    Teacher t3 = Teacher("yangqiang", "UC");//匿名对象，编译器优化，直接用创建临时对象的参数来创建1个新对象，不t2会调用复制构造函数
    t2 = t3;//赋值
    cout <<"................"<< std::endl;
    t2 = Teacher("徐薇","咨询");//赋值，不会调复制构造函数，因为没有新对象，临时对象当场释放
    cout << "................" << std::endl;
    system("pause");
}