class Date
{
private:
  int _year;
  int _month;
  int _day;
  const int _N;//必须要初始化，但是不能在这里（声名）初始化，
  int& _ref;//引用，必须要初始化
  A _aa;//没有默认构造函数的自定义类型的成员变量
  //自定义类型会在定义的时候调用构造函数
public:
  //初始化列表 - 只有构造函数才可以，
  //每个对象的成员变量定义的地方
  //用;开始，用，进行间隔，括号就是其定义的值
  Date(int year, int month, int day,int i)//：开始，间隔
    :_year(year)
    , _month(month)
    , _day(day)
    ,_N(10)//这样就可以用了
    ,_ref(i)//在定义的地方初始化，
    ,_aa(1)//这样初始化也行
  { }
  //这样也可以用
  //Date(int year, int month, int day)
  //  :_N(10)
  //{
  //  _year = year;
  //  _month = month;
  //  _day = day;
  //}
};

void initlist()//初始化列表
{
  //Date d(2022, 1, 19);//对象实例化，对象定义
  const int j = 2;//常量必须才定义的时候初始化，
  int i = 2;
  Date s(2022, 12, 3, i);
}

class Date1
{
public:
  /* Date1(int year)
   :_year(year)
  {}*/
  explicit Date1(int year)
   :_year(year)
  {}
private:
  int _year;
};

void explicit_test()
{
  Date1 d(2022);
  Date1 d2 = 2022;//也允许这样的事情发生，并且都是去调用构造函数
  //叫做隐式类型转换，
  //d2的实际过程是2022先构造一个临时变量Date tmp(2022)，再用这个对象去拷贝构造d2
  //但是c++编译器对于连续过程中的构造会合二为一
  //所以这里就只有一个构造
  //但是如果不想这样实现，我们前面加一个explicit就不会发生这样的转换了
  //类比c语言
//  隐式类型转换--相近的类型---表示意义相似的类型
  double d = 101;
  int ii = d;//
  //强制类型转换--把不相关的类型---
  int* p = ⅈ
  int k = (int)p;//
  //如我们以后学习的string类
  string s1("hello world");
  string s2 = "hell";
  //这也是这种情况
}

class B
{
private:
  int _a=0;//这里可以用，这个是给个缺省值，并不是初始化的地方
  //静态成员变量属于整个类，只属于这个类，所有的对象，生命周期再整个程序运行期间
  //类的成员函数在中可以随便范围
  static int _Scount;//声名
public:
  B(int a=0)
    :_a(a)
    ++_Scount;
  }
  B(const B&b)
    :_a(b._a)
  {
    ++_Scount;
  }
  //静态的成员函数，没有this指针，只能访问静态的的成员变量和成员函数
  //不能访问那些_a这些成员变量，
  static int Getcount()
  {
    return _Scount;
  }
};
int B::_Scount = 0;//定义初始化，
void f(B b)
{
}
//类外面访问
void static_test()
{
  B b1;
  B b2 = 1;
  f(b1);
  //cout <<B::_Scount  << endl;//值都是一样的，属于所有的对象
  //cout << b1._Scount << endl;
  cout << b1.Getcount() << endl;
}

class sum
{
public:
  sum()//sum是构造函数，每次调用构造函数，_ret就会加上，_i也会自增
  {
    _ret += _i;
    ++_i;
  }
  static int GetRet()
  {
    return _ret;
  }
private:
  //使用静态成员变量
  //声名
  //静态成员变量
  static int _i;//i是每次的加的数
  static int _ret;//ret用来记录总数d
};
//定义
int sum::_i = 1;
int sum::_ret = 0;
class Solution {
public:
  int sumNums(int n) {
    sum a[n];//对数组里面每个成员都要初始化，去调用构造函数，
    return sum::GetRet();
  }
};class sum
{
public:
  sum()//sum是构造函数，每次调用构造函数，_ret就会加上，_i也会自增
  {
    _ret += _i;
    ++_i;
  }
  static int GetRet()
  {
    return _ret;
  }
private:
  //使用静态成员变量
  //声名
  //静态成员变量
  static int _i;//i是每次的加的数
  static int _ret;//ret用来记录总数d
};
//定义
int sum::_i = 1;
int sum::_ret = 0;
class Solution {
public:
  int sumNums(int n) {
    sum a[n];//对数组里面每个成员都要初始化，去调用构造函数，
    return sum::GetRet();
  }
};