【C++】类与对象 （四）初始化列表 static成员 友元 内部类 匿名对象 拷贝对象时的一些编译器优化（2）

#include<iostream>
using namespace std;
class A
{
public:
  A()
    :_a(10)
    ,_b('a')
  {
  }
private:
  int _a;
  char _b;
  static int c;//这里不能给缺省值，缺省值是给初始化列表使用的，
               //初始化列表只能初始化非静态成员
};
int A::c = 10;
int main()
{
  A aa;
  return 0;
}

#include<iostream>
using std::cout;
using std::endl;
class A
{
public:
  A()
    :_a(10)
  {
    _count++;
  }
  A(const A& tmp)
  {
    _a = tmp._a;
    _count++;
  }
private:
  static int _count;
  int _a;
};
int A::_count = 0;
int main()
{
  A aa1;
  A aa2;
  A aa3(aa1);
  A aa4(aa2);
  return 0;
}

#include<iostream>
using namespace std;
class Date
{
  friend ostream& operator<<(ostream& _cout, const Date& d);//友元函数的声明
  friend istream& operator>>(istream& _cin, Date& d);//友元函数的声明
public:
  Date(int year = 1900, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
  {}
private:
  int _year;
  int _month;
  int _day;
};
//运算符重载
ostream& operator<<(ostream& _cout, const Date& d)
{
  _cout << d._year << "-" << d._month << "-" << d._day;//不使用友元函数，无法访问这里的成员变量。
  return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
  _cin >> d._year;    //不使用友元函数，无法访问这里的成员变量。
  _cin >> d._month;   //不使用友元函数，无法访问这里的成员变量。
  _cin >> d._day;     //不使用友元函数，无法访问这里的成员变量。
  return _cin;
}
int main()
{
  Date d;
  cin >> d;
  cout << d << endl;
  return 0;
}

//友元类
class Time
{
  friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
  Time(int hour = 0, int minute = 0, int second = 0)
    : _hour(hour)
    , _minute(minute)
    , _second(second)
  {}
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
  {}
  void SetTimeOfDate(int hour, int minute, int second)
  {
    // 直接访问时间类私有的成员变量
    _t._hour = hour;
    _t._minute = minute;
    _t._second = second;
  }
private:
  int _year;
  int _month;
  int _day;
  Time _t;
};

//内部类
#include<iostream>
using namespace std;
class A
{
private:
  static int k;
  int h;
public:
  class B // B天生就是A的友元
  {
  public:
    void foo(const A& a)
    {
      cout << k << endl;//OK
      cout << a.h << endl;//OK
    }
  };
};
int A::k = 1;
int main()
{
  A::B b;
  b.foo(A());
  return 0;
}

//例如 A是一个类
A();//定义一个匿名对象

//匿名对象
#include<iostream>
using namespace std;
class A
{
public:
  A(int a = 0)
    :_a(a)
  {
    cout << "A(int a)" << endl;
  }
  ~A()
  {
    cout << "~A()" << endl;
  }
private:
  int _a;
};
class Solution {
public:
  int Sum_Solution(int n) {
    //...
    return n;
  }
};
int main()
{
  A aa1;
  // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
  //A aa1();
  // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
  // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
  A();
  A aa2(2);
  // 匿名对象在这样场景下就很好用，如果不定义匿名对象我们就要创建一个Solution这样的对象。
  Solution().Sum_Solution(10);
  return 0;
}

//拷贝对象时的一些编译器优化
#include<iostream>
using namespace std;
class A
{
public:
  A(int a = 0)
    :_a(a)
  {
    cout << "A(int a)" << endl;
  }
  A(const A& aa)
    :_a(aa._a)
  {
    cout << "A(const A& aa)" << endl;
  }
  A& operator=(const A& aa)
  {
    cout << "A& operator=(const A& aa)" << endl;
    if (this != &aa)
    {
      _a = aa._a;
    }
    return *this;
  }
  ~A()
  {
    cout << "~A()" << endl;
  }
private:
  int _a;
};
void f1(A aa)
{
}
A f2()
{
  A aa;
  return aa;
}
A f3()
{
  return A();
}
int main()
{
  // 传值传参 不优化
  A aa1;    
  f1(aa1);
  cout << "----------------------------------------------------" << endl;
  // 传值返回
  f2();    //不优化  调用一个构造函数+一个拷贝构造   因为是两行代码编译器不敢擅自优化
  cout << "----------------------------------------------------" << endl;
  // 隐式类型，构造+拷贝构造->优化为直接构造
  f1(1);
  // 一个表达式中，构造+连续拷贝构造->优化为一个构造
  f1(A(2));
  cout << "----------------------------------------------------" << endl;
  // 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
  A aa2 = f2();
  cout << "----------------------------------------------------" << endl;
  // 一个表达式中，连续拷贝构造+赋值重载->无法优化
  aa1 = f2();
  cout << "----------------------------------------------------" << endl;
  f3(); //一行中构造+拷贝构造 ->优化为一个构造
  A aa3 = f3(); //一行中构造+拷贝构造+拷贝构造 ->优化为一个构造
  return 0;
}