【C++】深入探索类和对象：初始化列表及其static成员与友元（一）

一、构造函数体赋值

构造函数作用:在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Data
{
public:
  Data()//错误的
  { 
    _n = 10;//左值不可修改
    _a = 1;
    _a = 10;
  }
private:
  int _a;
  const int _n;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

二、初始化列表

2.1 初始化列表概念

初始化列表是每个成员变量定义初始化的位置。以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或者表达式。

class Date
{
public:
  Date(int year,int month,int day)
    :_n(1)
    ,_month(2)
  {
        //赋值修改
    _year = year;
    _month = month;
    _day = day;
  }
private:
    //声明
  int _year=2020;//缺省值
  int _month;
  int _day;
  const int _n;
};
int main()
{
  Date d1(2024,3,4);
  return 0;
}

从调试结果上来看，调用构造函数时，在初始化列表完成对成员对象的初始化;初始化列表结束后，进入函数体内完成赋初值。

如果没有在成员变量声明中给缺省值(在初始化列表使用)或在初始化列表中完成初始化，编译器会给随机值，之后是函数体里面的事

2.2 如何使用初始化列表

能使用初始化列表就使用初始化列表，由于不管没有初始化列表，编译器都会在初始化列表中完成初始化，再进函数体赋值。

虽然大部分成员变量可以在函数体中赋值，但是函数体可以对于成员多次赋值，不好控制。有些成员变量必须通过初始化列表完成初始化，不能进入函数体再赋值，比如:引用、const修饰成员

初始化列表的特性:

第一点:每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

第二点:类中包括以下成员，必须放在初始化列表位置进行初始化

• 引用成员变量
  
• const成员变量
  
• 自定义类型成员(且该类有显示构造函数时)
  
• 其他成员，可以在初始化列表，也可以在函数体内；但是建议在初始化处理
  

class A
{
public:
  A(int a)
    :_a(a)
  {
  }
private:
  int _a;
};
class B
{
public:
  B(int data,int& ref)
    :data(10)
    ,_n(1)
    ,ref(ref)
  {
  }
private:
  int data;
  const int _n; //const修饰成员变量
  int& ref; //引用
  A _aa; //没有默认构造函数
};
int main()
{
  int x = 10;
  B d1(20,x);
  return 0;
}

对于类类型成员有显示构造函数，才必要初始化列表中初始化。

在初始化列表中是不对自定义类型初始化，而是通过编译器调用对应默认构造函数完成初始化，不需要在初始化列表中初始化

第三点:在实际中是混着使用，初始化列表也可以调用函数，并且跟函数体内一样，需要考虑类型问题及其无法对指针进行判空的风险。

class A
{
    public:
    A()
        :_P((int *)malloc(4))
   private:
    int *_p2=(int *)malloc(4)
}

第四点:成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化表中的先后次序无关

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();
  return 0;
}

在初始化列表中顺序尽量对应着声明的顺序，这样子方便查看类中成员变量

2.3 构造函数支持隐式类型转换

构造函数不仅可以初始化对象，对于单个参数或者第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

关于类型转换:

int i = 1;
const double &d=i;

这个表达式没有报错，进行了隐式类型的转换，将整型类型转换为double类型，并且将值存放在临时变量(临时变量具有常性)。对此需要const进行修饰。

2.3.1 单参数隐式类型转换

对于自定义类型C cc = 2 ,其中支持隐式类型转换。当然这需要构造函数实现，单参数构造函数支持隐式类型转换。(整型类型通过隐式类型转换为自定义类型，并将值存储在临时变量中)

class C
{
public:
  C(int x=0)
    :_x(x)
  {
  }
  C(const C& cc)
  {
  cout << "C(const C& cc)" << endl;
  }
private:
  int _x;
};
int main()
{
  C cc2=2;
  const C& cc2 = 3; 
  return 0;
}

如果不存在从"int"转换到"C"的适当构造函数，就无法发生隐式类型转换

关于上面两种写法是等效的，但是推荐使用第二种写法更加简洁。首先整型类型2通过隐式类型转换构造出临时对象，在Push接口中进行拷贝构造。现在编译器可能进行优化，同一个表达式中连续步骤构造，一般会被合二为一。

2.3.2 双参数隐式类型转换(C++11中支持)

这属于多参数隐式类型转换，不涉及std::initializer_list初始化列表。

class A
{
public:
  A(int a1,int a2)
    :_a1(a1)
    ,_a2(a2)
  {}
private:
  int _a1;
  int _a2;
};
int main()
{
  A aa1 = { 1,2 };
  const A& aa2 = { 1,2 };
}

【C++】深入探索类和对象：初始化列表及其static成员与友元（二）https://developer.aliyun.com/article/1617302