【C++初阶：类和对象(下篇)】初始化列表 | static成员 | 友元 下

class A
{
public:
  A(int a = 0)
    : _a(0)
  {}
private:
  int _a;
};
class B
{
private:
  //缺省值 
  int _b = 0;
  int* p = (int*)malloc(sizeof(int)*10);
  A _aa = A(10);//先构造再拷贝构造，优化为构造
  A _aa = 10;//同上，建议
  //static int _n = 10;//err,静态变量不能给缺省值
};
int main()
{
  B bb; 
  return 0;
}

class Date
{
  friend ostream& operator<<(ostream& out, const Date& d);//友元，位置可任意，一般是开头
  friend istream& operator>>(istream& in, Date& d);//友元
public:
  Date(int year = 0, int month = 0, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
  {}
  /*void operator<<(ostream& out)
  {
    out << _year << "/" << _month << "/" << _day << endl;
  }*/
private:
  int _year;
  int _month;
  int _day;
};
ostream& operator<<(ostream& out, const Date& d)//支持连续输出
{
  out << d._year << "/" << d._month << "/" << d._day << endl;
  return out;
}
istream& operator>>(istream& in, Date& d)//支持连续输入
{
  in >> d._year >> d._month >> d._day;
  return in;
}
int main()
{
  Date d1, d2;
  cin >> d1 >> d2;
  //cout << d1 ? d1 << cout
  //cout << d1;
  /*d1.operator<<(cout);
  d1 << cout;*/
  cout << d1 << d2;
  return 0;
}

class A
{
  friend void f(const A& aa, const B& bb);
public:
  A(int a = 0)
    : _a(0)
  {}
private:
  int _a;
};
class B
{
  friend void f(const A& aa, const B& bb);
private:
  int _b = 0;
  A _aa;
};
void f(const A& aa, const B& bb)
{
  cout << aa._a << endl;  
  cout << bb._b << endl;
}
int main()
{
  A aa;
  B bb;
  f(aa, bb);
  return 0;
}

class Date; //前置声明
class Time
{
  friend class Date; //声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
  Time(int hour, int minute, int second)
  : _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;
};

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  
    }
  private:
    int _b;
  };
};
int A::k = 0;
int main()
{
  cout << sizeof(A) << endl;//4
  A::B b;//要用B去定义，必须得指定域
  b.foo(A());
  return 0;
}

class Sum
{
public:
    Sum()
    {
        _ret += _i;
        _i++; 
    }
    static int GetRet()//在保证封装的情况下访问_ret
    {
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};
//定义
int Sum::_i = 1;
int Sum::_ret = 0;
class Solution 
{
public:
    int Sum_Solution(int n) 
    {
        Sum a[n];//调用n次构造
        return Sum::GetRet();
    }
};

#include<iostream>
using namespace std;
class Solution 
{
private:
  //内部类，为Solution解决1+...+n的问题，更好的体现了封装。
  class Sum
  {
  public:
      Sum()
      {
          _ret += _i;
          _i++; 
      }
  };
public:
    int Sum_Solution(int n) 
    {
        Sum a[n];//调用n次构造
        return _ret;
    }
private:
  static int _i;
  static int _ret;
};
int Solution::_i = 1;
int Solution::_ret = 0;

#include<iostream>
using namespace std;
int main()
{
  //static int monthDays[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,30,31};
    //改造：
    static int monthDays[13] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
    //2021 10 18
    int year, month, day;
    cin >> year >> month >> day;
    int n = monthDays[month-1] + day;
    //判断2月,注意这里不是等于而是大于
    if(month > 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
    {
        n++;    
    }
    cout << n << endl;
    return 0;
}