C++类与对象（四）：再谈构造函数（详解初始化列表）、Static成员

class Date
{
public:
  Date(int year = 2024, int month = 1, int day = 1)//使用全缺省，也是默认构造函数
  {
    //函数体内初始化，在函数体内进行赋值
    _year = year;
    _month = month;
    _day = day;
  }
private:
  int _year;//变量声明
  int _month;
  int _day;
};

class Date
{
public:
  Date(int year = 2024, int month = 1, int day = 1)//使用全缺省，也是默认构造函数
    :_year(year)
    ,_month(month)
    ,_day(day)  //初始化列表
  {
  }
private:
  int _year;
  int _month;
  int _day;
};

class Date
{
public:
  Date(int year = 2024, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)  //这三个可以在这，也可以在函数体内
    ,_ref(year)
    ,_n(1)  //这两个必须在这里
  {
  }
    //两个地方可以混着用，这样也行  
  //Date(int year = 2024, int month = 1, int day = 1)
  //  : _ref(year)
  //  , _n(1)  //这两个必须在这里
  //{
  //  _year = year;//没有在初始化列表显示出来定义，但是也会定义和初始化，不过内置类型随机值。
                                            //自定义类型调用自己的默认构造函数
  //  _month = month;
  //  _day = day;//这三个可以在这，也可以在初始化列表内
  //}
private:
  int _year;//这些都是声明，还没有空间
  int _month;
  int _day;
  int& _ref;//引用，必须在定义的时候初始化
  const int _n;//常量，必须在定义的时候初始化
};
int main()
{
  //实例化对象
  Date d1;//此时才定义，但是对象整体定义； 那每个成员在哪里定义呢？——就在初始化列表
  return 0;
}

class Date
{
public:
  //两个地方可以混着用，这样也行
  Date(int year = 2024, int month =1, int day = 1)
    : _ref(year)
    , _n(1)  //这里给1，看结果
  {
    _year = year;
    _month = month;
    _day = day;//这三个可以进行赋值
  }
private:
  int _year=1;//只给_year缺省值
  int _month;
  int _day;
  int& _ref;//引用，必须在定义的时候初始化
  const int _n=2;//这里给2
};

class Stack
{
public:
  Stack(int capacity)
  {
    //.......
  }
  //没有默认构造函数了
private:
  int* _a;
  int _top;
  int _capacity;
};
class MyQueue
{
public:
  //此时都是自定义类型，但是又没有默认构造函数；或者有但是不想用。就要自己初始化
  MyQueue()
    :_s1(4)//自己显示地初始化
    , _s2(5)
  {
  }
private:
  Stack _s1;
  Stack _s2;
};

class Stack
{
public:
  Stack(int capacity=3)
  {
    cout << "调用了Stack的默认构造函数";
    //.......
  }
private:
  int* _a;
  int _top;
  int _capacity;
};
class MyQueue
{
public:
private:
  Stack _s1;
  Stack _s2;//这俩可调用Stack类的默认构造
  int _size = -1;//给了缺省值
  //此时可以简单点理解：该类的默认构造函数对于自定义就去调用他们的，对于内置使用缺省或随机值
};

class Stack
{
public:
  Stack(int capacity=3)
  {
    cout << "调用了Stack的默认构造函数";
    //.......
  }
  //没有默认构造函数了
private:
  int* _a;
  int _top;
  int _capacity;
};
class MyQueue
{
public:
  MyQueue()//有没有效果一样，没写就按照默认构造函数那老一套
  { }  //写了初始化列表一定会走，但没有显示的写那也是老一套
private:
  Stack _s1;
  Stack _s2;//这俩可调用Stack类的默认构造
  int _size = -1;//给了缺省值
};

class A
{
public:
  A(int a = 0)
    :_a(a)
  { }
private:
  int _a;
};
int main()
{
  A a1(1);//这样创建对象大家都知道
  A a2 = 2;//这样也可以：内置类型对象隐式转换为自定义类型对象
           //能这样做，是A的int单参数构造函数支持的
       //其实隐式转换中间产生一个临时变量，临时变量是A类型的
  const A& ra = 3;//给临时变量起别名，这时临时变量会在引用的作用域结束时销毁
  return 0;
}

class Date
{
public:
   Date(int year, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
  { }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1(2024, 1, 6);
    Date d2=2024;//
    //Date d2 = { 2024,1,1 };这样也行
  Date d3 = (2024, 1, 1);//这样是逗号表达式子<==> Date d3=1 <==> Date d3=(Date)1 <==> Date d3(1)
  return 0;
}

class Date
{
public:
  // explicit修饰构造函数，禁止类型转换
   Date(int year=1, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
  { }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  Date d2 = { 2024,2 };//从左到右依次赋值
  Date d3 = { 2024,2,2 }; //这样也行
  Date d4 = 2024;
  return 0;
}

#include<iostream>
using namespace std;
class A
{
public:
  A()//无参构造
  {
    count++;
  }
  A(A& a)//拷贝构造
  {
    count++;
  }
  static int count;//类内声明，属于整体（公有）
};
int A::count = 0;//类外定义，就类似于成员函数声明和定义分离
int main()
{
  A aa;
  cout << A::count << endl;//正常大家会想到这样访问
  cout << aa.count << endl;//这样也可以，类比调用成员函数：告诉编译器去那个类里找
}

using namespace std;
class A
{
public:
  A()//无参构造
  {
    count++;
  }
  A(A& a)//拷贝构造
  {
    count++;
  }
  int getCount()
  {
    return count;
  }
private:
  static int count;//类内声明，属于整体（私有）
};
int A::count = 0;//类外定义
int main()
{
  A aa;
  cout << aa.getCount()-1 << endl;//因为为了得到count而特地创建了一个对象来调用get函数，要-1；
}

class A
{
public:
  A()//无参构造
  {
    count++;
  }
  A(A& a)//拷贝构造
  {
    count++;
  }
  static int getCount()//静态成员函数，没有this指针，所以不能访问非静态成员变量
  {
    return count;
  }
private:
  static int count;//类内声明，属于整体（公有）
};
int A::count = 0;//类外定义
int main()
{
  A aa;
  cout << A::getCount()-1 << endl;//可以直接用类名调用
    cout << aa.getCount << endl;//这样也行
}