C++类和对象（下）：初始化列表

一.初始化列表

--之前我们实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有一种方法，就是初始化列表。

初始化列表的特点：

• 初始化列表的使用方式是以一个冒号开始，接着是⼀个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
• 每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。
• 引用成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始化，否则会编译报错。
• C++11支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。
• 尽量使用初始化列表初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。
• 初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持⼀致

初始化列表总结：

• 无论是否显示写初始化列表，每个构造函数都有初始化列表；
• 无论是否在初始化列表显示初始化成员变量，每个成员变量都要走初始化列表初始化。

--上述的这些特点在举例说明中都会体现出来

举例说明：(注意看注释)

• 基础用法：

  #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), _ref(x), _n(1){// error C2512: “Time”: 没有合适的默认构造函数可用// error C2530 : “Date::_ref” : 必须初始化引用// error C2789 : “Date::_n” : 必须初始化常量限定类型的对象}void Print() const{cout << _year << "-" << _month << "-" << _day << endl;}
  private:int _year;int _month;int _day;//我们可以这样理解:必须初始化的都需要在初始化列表初始化，要么就给缺省值。//不给就会上面的那些错误Time _t; // 没有默认构造int& _ref; // 引用const int _n; // const
  };
  int main()
  {int a = 0;//对象整体定义,再传参给引用Date d1(a);d1.Print();return 0;
  } 

• 用初始化列表解决MyQueue类的一些问题：

  //通过上面的初始化列表，我们之前MyQueue类的一些问题也可以得到解决
  //这里就大概实现一部分，仅作为演示使用
  #include<iostream>
  using namespace std;
  class Stack
  {
  public:Stack(int n)//这里给的不是默认构造{cout << "Stack(int n)" << '\n';}
  };class MyQueue
  {
  public://MyQueue(int n = 4)//{//	//这里如果直接这样写会去调用Stack的默认构造函数//	//但是没有，所以这里会报错。//}//我们可以利用初始化列表有效解决这个问题MyQueue(int n = 4):_st1(n), _st2(n){}
  private:Stack _st1;Stack _st2;
  };int main()
  {MyQueue q1;return 0;
  }

• 声明时利用缺省值初始化

  //其实除了初始化列表以外，我们还可以这样玩
  #include<iostream>
  using namespace std;
  class Time
  {
  public:Time(int hour):_hour(hour){cout << "Time()" << endl;}
  private:int _hour;
  };
  class Date
  {
  public:Date():_year(100){}void Print() const{cout << _year << "-" << _month << "-" << _day << endl;}
  private://注意:这里不是初始化，而是给的缺省值，这个缺省值是给初始化列表的//每个成员变量都会走初始化列表，如果未显示在初始化列表，则会按缺省值初始化//如果都没有，那内置类型可能就是随机值，之前提到过的那三种就是直接报错int _year=1;int _month=1;int _day;Time _t = 1;// 没有默认构造const int _n=1; // constint* _ptr = (int*)malloc(40);
  };
  int main()
  {Date d1;d1.Print();return 0;
  }

• 构造函数都有初始化列表了，为什么还需要那个括号

  那为什么都使用了初始化列表了，还需要那个括号呢
  我们来看看下面这个场景
  #include<iostream>
  using namespace std;
  class A 
  {
  public:A(int n = 10):_a((int*)malloc(sizeof(int)* n)), _size(0){//上面的_a的空间是否开辟成功是不是需要在这里检查//以及给空间初始化是不是也得在这里实现if (_a == nullptr){perror("malloc fail!");exit(1);}memset(_a, 0, sizeof(int) * n);}
  private:int* _a;int _size;
  };
  int main()
  {A aa;return 0;
  }

  小练习：

• 答案：D

代码与解析：

//我们最后再来看个题
//注意_a1,_a2谁先初始化，以及最后结果是什么
#include<iostream>
using namespace std;
class A
{//初始化顺序跟出现在初始化列表的顺序无关，所以这里其实是_a2先初始化，_a1再初始化
public:A(int a):_a1(a), _a2(_a1){//_a2先初始化，此时_a1还没初始化，所以是随机值，最后_a2也就是随机值了//_a1再初始化,缺省值和初始化列表显示出现符合，按初始化列表的来，也就是1。}void Print() {cout << _a1 << " " << _a2 << endl;}
private://初始化列表按照成员变量在类中的声明顺序初始化//这里我们发现_a2先声明int _a2 = 2;int _a1 = 2;
};
int main()
{A aa(1);aa.Print();//1 随机值
}

二.类型转换

--我们之前接触过内置类型和内置类型之前的转换，那么我们现在再来看看内置类型和类类型，类类型之间的转换

类型转换的特点：

• C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。
• 构造函数前面加explicit就不再支持隐式类型转换。
• 类类型的对象之间也可以隐式转换，需要相应的构造函数支持。

--上述这些特点都会在举例说明中体现出来

举例说明：(注意看注释)

• 基本使用：

  #include<iostream>
  using namespace std;
  class A 
  {
  public://构造函数explict就不再支持隐式类型转换了//explict A(int a1)//这里的构造函数参数有相关内置类型A(int a1):_a1(a1){}
  private:int _a1 = 1;int _a2 = 2;
  };void func(const A& aa=1)
  {}class Stack 
  {
  public:void Push(const A& a){}};int main()
  {//1.内置类型之间的隐式类型转换int i = 1;double d = i;const double& ref1 = i;//这个我们之前也讲过，中间的临时对象具有常性//2.内置类型和类类型之间的隐式转换//需要有相关内置类型为参数的构造函数//这样写是直接构造A a1(1);//这个才涉及到隐式类型转换A a2 = 1;const A& ref2 = a1;const A& ref3 = 1;//三种都可以，因为上面的函数参数是用过const修饰的(所以第二种也ok)func(a1);func(1);func();//我们再来看看别的使用场景Stack s1;//这样写有点麻烦了A a3(3);s1.Push(a3);//我们可以直接这样,方便了很多s1.Push(3);return 0;
  }

• 多参数转化以及类和类之间的隐式类型转换

  //再来看看多参数转化以及类和类之间的隐式类型转换
  #include<iostream>
  using namespace std;
  class A
  {
  public:// 构造函数explicit就不再支持隐式类型转换// explicit A(int a1)A(int a1):_a1(a1){cout << "A(int a1)" << '\n';}A(const A& aa){cout << "A(const A& aa)" << '\n';}A(int a1, int a2):_a1(a1), _a2(a2){}int Get() const{return _a1 + _a2;}private:int _a1 = 1;int _a2 = 2;
  };class B
  {
  public://类和类之间的隐式类型转换，就需要参数是类类型相关了B(const A& a):_b(a.Get()){}
  private:int _b = 0;
  };int main()
  {//再来跟大家展示一个优化，上面没提到// 构造A a1(1);// 这里的隐式类型转换其实就是，2为参数构造临时对象，临时对象拷贝构造a2 -> 优化为直接构造A a2 = 2;const A& ref1 = 3;//C++11之后才支持多参数构造A a3(1, 1);A a4 = { 1, 1 };const A& ref2 = { 1, 1 };//Stack st1;//st1.Push(a4);//st1.Push({2,2});//类和类之间的隐式类型转换，跟上面原理类似B b1 = a3;const B& ref3 = a3;return 0;
  }

  三.static成员

static成员的特点：

• 用static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进行初始化。
• 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。
• 用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
• 静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。
• 非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
• 突破类域就可以访问静态成员，可以通过类名::静态成员 或者 对象.静态成员 来访问静态成员变量和静态成员函数。
• 静态成员也是类的成员，受public、protected、private 访问限定符的限制。
• 静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

--上述这些特点都会在举例说明中体现出来

举例说明：(注意看注释)

• 基础用法：

#include<iostream>
using namespace std;class A
{
public://非静态的成员函数，可以访问任意静态成员变量以及非静态的成员变量A(int a = 0):_a1(a),_a2(a){++_count;}A(const A& t){++_count;}static int GetCount(){// _a1++; 不能访问非静态成员，因为static成员函数没有thisreturn _count;}
private:int _a1 = 1;int _a2 = 1;
//public:// 在类里面声明，且这里不可以用缺省值static int _count;
};//必须在类外面初始化
int A::_count = 0;int main()
{//静态成员不存在对象之中A aa1;cout << sizeof(aa1) << endl;A* ptr = nullptr;A aa2 = 1;/*cout << ptr->_count<< endl;cout << aa1._count << endl;cout << A::_count << endl;*///变成私有的话，需要使用一下函数来获取了cout << A::GetCount() << endl;cout << aa2.GetCount() << endl;cout << ptr->GetCount() << endl;return 0;
}

练习题：https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=3&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

class Sum{
public:Sum(){_ret+=_i;_i++;}static int Get_Sum(){return _ret;}
private:static int _ret;static int _i;
};int Sum::_i=1;
int Sum::_ret=0;class Solution {
public:int Sum_Solution(int n) {Sum arr[n];return Sum::Get_Sum();}
};

• 练习2

  再来看个练习
  #include<iostream>
  using namespace std;
  class A
  {
  public:A(){cout << " A()" << endl;}~A(){cout << " ~A()" << endl;}
  };class B
  {
  public:B(){cout << " B()" << endl;}~B(){cout << " ~B()" << endl;}
  };class C
  {
  public:C(){cout << " C()" << endl;}~C(){cout << " ~C()" << endl;}
  };class D
  {
  public:D(){cout << " D()" << endl;}~D(){cout << " ~D()" << endl;}
  };//构造顺序
  //析构顺序
  C c;
  int main()
  {A a;B b;static D d;return 0;
  }

  --这个题大家可以自己思考一下，答案自己运行一下就出来了

四.友元

友元的特点：

• 友元提供了⼀种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到⼀个类的里面。
• 外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
• 一个函数可以是多个类的友元函数。
• 友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
• 友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但是B类不是A类的友元。
• 友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。
• 有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

--上述的这些特点在举例说明中都会体现出来

举例说明：(注意看注释)

• 友元函数：

  //友元函数
  #include<iostream>
  using namespace std;//前置声明，否则A的友元函数声明那里编译器不认识B
  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;
  }

• 友元类：

  //友元类，声明和定义需要分离，不然就算前置声明也解决不了问题，因为找不到类里面的成员
  #include<iostream>
  using namespace std;
  // xxx.h
  //前置声明
  class D;
  class C
  {// 友元声明friend class D;
  public:void func1(const D& dd);
  private:int _a1 = 1;int _a2 = 2;
  };class D
  {friend class C;
  public:void func1(const C& aa);void func2(const C& aa);
  private:int _b1 = 3;int _b2 = 4;
  };// xxx.cpp
  void C::func1(const D& dd)
  {cout << dd._b1 << endl;
  }void D::func1(const C& aa)
  {cout << aa._a1 << endl;cout << _b1 << endl;
  }void D::func2(const C& aa)
  {cout << aa._a2 << endl;cout << _b2 << endl;
  }int main()
  {C cc;D dd;dd.func1(cc);dd.func2(cc);return 0;
  }

  五.内部类

内部类的特点：

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

--上述这些特点都会在举例说明中体现出来

举例说明：(注意看注释)

• 基本用法：

  //内部类
  #include<iostream>
  using namespace std;class A
  {
  public://内部类class B //B默认是A的友元类{public:void fun(const A& a){cout << _k << '\n';//okcout << a._h << '\n';//ok}private:int _b1;};
  private:static int _k;int _h = 1;
  };int A::_k = 1;
  int main()
  {//静态成员变量和内部类都不算cout << sizeof(A) << '\n';//4//受外部类类域限制和访问限定符限制A::B b;A aa;b.fun(aa);return 0;
  }

  

• 我们学完个之后可以优化一下上面那个从1加到n的题

  class Solution {class Sum {public:Sum() {_ret += _i;_i++;}};public:int Sum_Solution(int n) {Sum arr[n];return _ret;}
  private:static int _ret;static int _i;
  };
  int Solution::_i = 1;
  int Solution::_ret = 0;

  六.匿名对象

匿名对象的特点：

• 用类型(实参) 定义出来的对象叫做匿名对象，相比之前我们定义的 类型 对象名(实参) 定义出来的叫有名对象
• 匿名对象生命周期只在当前一行，一般临时定义⼀个对象当前用一下即可，就可以定义匿名对象。

--上述这些特点都会在举例说明中体现出来

举例说明：(注意看注释)

• 基本用法：

  匿名对象
  先拿上面的为例
  #include<iostream>
  using namespace std;
  class Solution {class Sum {public:Sum() {_ret += _i;_i++;}};public:int Sum_Solution(int n) {//Sum arr[n];//要变长数组，vs不支持return _ret;}//加个clear和析构void clear(){_i = 1;_ret = 0;}~Solution(){cout << "~Solution()" << '\n';}private:static int _ret;static int _i;
  };
  int Solution::_i = 1;
  int Solution::_ret = 0;void fun(const Solution& s=Solution(),int i=1)//缺省值直接给匿名对象
  {}
  int main()
  {Solution s;//有名对象cout << s.Sum_Solution(10) << '\n';s.clear();//匿名对象的生命周期只在当前行//Solution(); //匿名对象//const 引用会延长匿名对象的生命周期，生命周期跟const 引用一样//const Solution& ref = Solution();cout << Solution().Sum_Solution(10) << '\n';//这样就可以直接一行搞定了fun(Solution());fun(s);fun();return 0;
  }