一、构造函数补充

对于之前讲解的构造函数，还有一些更深层次的内容要进行补充，接下来进行补充内容的讲解。

1、初始化列表

在我们学习构造函数的时候想要去初始化成员变量主要是使用函数体内赋值，接下来我们要介绍另一种构造函数方式：初始化列表。
首先我们来看一段代码：

 class Date
 {
 public:
   Date(int& x,int year = 1,int month = 1, int day = 1)
      :_year(year)
      ,_month(month)
      ,_day(day)
  {
  }
      

上面的代码展示了初始化列表的具体写法，初始化列表的使用方式是以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每一个“成员变量”后面跟一个放在括号中的初始值或表达式，可以写成一行也可以写成多行。
对于初始化列表，我们有几点需要注意：
1、每个成员变量在初始化列表中只能出现一次，我们可以认为初始化列表就是每个成员变量定义初始化的地方。
2、引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始化，否则会编译报错。

 #include<iostream>
 using namespace std;

class Time
{
public:
  Time(int hour)
     :_hour(hour)
   {
     cout << "Time()" << endl;
   }
private:
  int _hour;
};

class Date
{
public:
  Date(int& x,int year = 1,int month = 1, int day = 1)
      :_year(year)
      ,_month(month)
      ,_day(day)
      ,_t(12)
      ,_re(x)
      ,_n(1)
   {
   }
 void Print() const
 {
    cout << _year << "-" << _month << "-"  << _day << endl;
 }
private:
  int _year;
  int _month;
  int _day;

  Time _t;
  int& _re;
  const int _n;
};
int main()
{
  int i = 0;
  Date d1(i);
  d1.Print();
    
  return 0;
} 

注意：
引⽤成员变量，const成员变量，没有默认构造的类类型变量（上面的代码中展现了），必须放在初始化列表位置进⾏初始化，否则会编译报错。

同时初始化列表和之前我们学的函数体内赋值也可以混着用。
C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化的成员使⽤。

当我们不给缺省值时，对于没有显式在初始化列表初始化的内置类型成员是否初始化取决于编译器。
对于没有显式在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会报错。

C++规定：
⽆论是否显⽰写初始化列表，每个构造函数都有初始化列表，那些不在初始化列表初始化的成员变量也会走初始化列表，所以我们尽量写初始化列表。

二、类型转换

C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。

 #include<iostream>
 using namespace std;
 class A
 {
 public:
   A(int a1)
     :_a1(a1)
  {}
  A(int a1, int a2)
     :_a1(a1)
     ,_a2(a2)
  {}
  void Print()
  {
     cout << _a1 << " " << _a2 << endl;
  }
  int Get() const
  {
     return _a1 + _a2;
  }
private:
  int _a1 = 1;
  int _a2 = 2;
};
class B
{
public:
  B(const A& a)
     :_b(a,Get())
  {}
public:
   int _b = 0;
};
int main()
{
   A aa1 = 1;
   aa1.Print();
   
   const A& aa2 = 1;
   A aa3 = {2,2 };
   B b = aa3;
   const B& rb = aa3;
   return 0;
 } 

隐式类型转换生成的是临时对象，临时对象具有常性，所以要加上const引用。
注意：
1、构造函数前面加explicit就不再支持隐式类型转换。
2、类类型的对象之间也可以隐式转换，需要相应的构造函数支持。

三、static成员

C++中的静态成员分为静态成员变量和静态成员函数，它们属于类本身而非类的实例，所有对象共享这些成员。
用static修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外进行初始化。用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。

注意：
1、初始化

class MyClass {
public:
    static int count; // 声明
};
int MyClass::count = 0; // 类外初始化

突破类域就可以访问静态成员，可以通过类名::静态成员 或者 对象.静态成员 来访问静态成员变量和静态成员函数。

2、静态成员也是类的成员，受public、protected、private 访问限定符的限制。

 class Secret {
private:
    static int key;
public:
    static int getKey() 
    {
     return key;
    }
};
int Secret::key = 12345;

四、友元

在 C++ 中，友元（Friend） 是一种特殊的机制，允许一个类或函数访问另一个类的 私有（private） 和 保护（protected） 成员。友元打破了类的封装性，但为某些特殊场景提供了灵活性。

友元的分类：
友元分为：友元函数和友元类
友元的声明：
在函数声明或者类声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯。

1、友元函数

作用：外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。

 #include<iostream>
 using namespace std;
 class B;
 class A
 {
    //友元声明
    friend void func(const A& aa, const B& bb);
 private:
   int _a1 = 1;
   int _a2 = 2;
 };
 class B
 {
   //友元声明
   friend void func(const A& aa, const B& bb);
 private:
    int _b1 = 3;
    int _b2 = 4;
 };
 void func(const A& aa, const B& bb)
 {
   cout << aa._a1 << endl;
   cout << bb._b1 << endl;
 }
 int main()
 {
   A aa;
   B bb;
   func(aa, bb);
   return 0
}

例如在上面的代码中，func函数前面加了friend，那么这里func就是A的友元，func就可以访问A的成员。

注意：
1、友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。
2、⼀个函数可以是多个类的友元函数。

2、友元类

#include<iostream>
using namespace std;
class A
{
  friend class B;
private:
  int _a1 = 1;
  int _a2 = 2;
};
class B
{ 
public:
void func1(const A& aa)
{
cout << aa._a1 << endl;
cout << _b1 << endl;
} 
void func2(const A& aa)
{
 cout << aa._a2 << endl;
 cout << _b2 << endl;
 }
private:
  int _b1 = 3;
  int _b2 = 4;
}；
int main()
{
A aa;
B bb;
bb.func1(aa);
bb.func2(aa);
return 0;
}

注意：
1、友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
2、友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。
3、友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。

五、内部类

如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独⽴的类，跟定义在全局相⽐，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类，内部类默认是外部类的友元类，内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使⽤，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地⽅都⽤不了。

六、匿名对象

⽤ 类型(实参) 定义出来的对象叫做匿名对象，相⽐之前我们定义的 类型 对象名(实参) 定义出来的叫有名对象。

匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对象。

到这里类和对象的学习就算结束啦，大家多多支持哦！