【C++】类和对象（下）—— 再谈构造函数 | static成员 | C++11补丁 |友元(上）

class Date
{
public:
    Date(int year, int month, int day)
 {
      _year = year;
      _month = month;
      _day = day;
 }
private:
     int _year;
     int _month;
     int _day;
};

class Date
{
public:
  Date(int year, int month, int day)
  : _year(year)
  , _month(month)
  , _day(day)
  {}
private:
  int _year; //声明
  int _month;
  int _day;
};
int main()
{
  Date d1(2022, 2, 22); 
  return 0;
}

class Date
{
public:
  Date(int year, int month, int x)
  : _N(10)
  , _ref(x)
  {
  _year = year;
  _ref++;
  }
private :
  const int _N;//声明
  int& _ref;
  int _year;
  int _month;
  int _day;
};
int main()
{
  int x = 0;
  Date d1(2022, 2, x);
  return 0;
}

class Time
{
public: 
    Time(int hour)
    {
        _hour = hour;
    }
private:
  int _hour;
};
class Date
{
public: 
    //要初始化_t 对象，只能通过初始化列表
    Date(int year, int hour)
     :_t(hour)
    {
       _year =year;
    }
private: 
    int _year;
    Time _t;
};
int main()
{
    Date d(2022,1)
    return 0;
}

class Time
{
public:
    Time(int hour = 0)
    {
        _hour = hour;
    }
private:
    int _hour;
};
class Date
{
public:
    //要初始化_t 对象，只能通过初始化列表
    //Date(int year, int hour)
    //    :_t(hour)
    //{
    //    _year = year;
    //}
    //在函数体内赋值，但是还是会先走初始化列表调用Time的默认构造，不健康
    Date(int year, int hour)
    {
        _year = year;
        Time t(hour);
        _t = t;
    }
private:
    int _year;
    Time _t;
};
int main()
{
    Date d(2022, 1);
    return 0;
}

class A {
public:
  A(int a)
  :_a1(a)  //第二
  , _a2(_a1)  //第一
  {}
  void Print() {
  cout << _a1 << " " << _a2 << endl;
  }
private:
  int _a2; //初始化顺序 - 声明顺序
  int _a1;
};
int main() {
  A aa(1);
  aa.Print();
}
问：
A.输出 1 1 
B.程序崩溃
C.编译不通过
D.输出1 随机值

#include<iostream>
using namespace std;
class Date
{
public:
  Date(int year)
  :_year(year)
  {
  cout << "Date(int year)" << endl;
  }
  Date(const Date& dd)
  {
  _year = dd._year;
  cout << "Date(const Date& year)" << endl;
  }
private:
  int _year;
};
int main()
{
  Date d1(2002);//直接调用构造
  Date d2 = 2022;//思考？  隐式类型转化：构造 + 拷贝构造 + 优化 》直接调用构造
  return 0;
}

// 隐式类型转换 - 相近类型 
  double d = 1.1;
  int i = d;
  const int& i = d;

Date tmp(2022); //先构造
Date d2(tmp); //再拷贝构造

Date(2022,10,26); //匿名对象————声明周期只有这一行
Solution slt;
slt.Sum_Solution(10);//有名对象调用，专门开辟了slt来调用
//匿名对象调用
Solution().Sum_Solution(10);//节省空间

#include<iostream>
using namespace std;
class A
{
public:
  A(int a = 0)
  : _a(a)
  {
  _scount++;
  }
  A(const A& aa)
  : _a(aa._a)
  {
  _scount++;
  }
  int getCount()
  {
  return _scount;
  }
private:
  int _a;
  static int _scount; //静态成员变量
};
int A::_scount = 0; //静态成员变量必须在类外的全局定义
int main()
{
  A a1;
  A a2;
  A a3(a2);
  cout << a1.getCount() << endl; //通过对象来访问成员函数
  return 0;
}

class A
{
public:
  A(int a = 0)
  :_a(a)
  {
  _scount++;
  }
  A(const A& aa)
  :_a(aa._a)
  {
  _scount++;
  }
  //静态成员函数  -- 没有this指针，不能访问非静态的成员
  static int GetCount()
  {
  return _scount;
  }
private:
  int _a;
  //静态成员变量，属于整个类，存在于静态区，生命周期在整个程序运行期间
  static int _scount;
};
int A::_scount = 0;
int main()
{
  A a1;
  A a2;
  A a3(a2);
  cout << A::GetCount() << endl;//可以通过类域来找 —— 突破类域
  cout << a1.GetCount() << endl;//也可以通过对象来找
}