【C++】详解初始化列表，隐式类型转化，类静态成员，友元

前言

初始化列表是对构造函数内容的补充，小编会详细的讲解初始化列表的概念，特性，注意点。这是本篇内容的重头戏，小编会先提一个问题来抛砖引玉。

隐式类型转换顾名思义，首先它不需要主动转换，然后就是不同类型之间的转换。

如果把在类成员前面加上static关键字会发生什么，小编也会详细讲解。

对于友元，小编会解析它的概念和用法

小编希望这篇文章能带给大家启发，相互探讨其中的奥秘。本篇内容如有不足之处，还请指正，小编会虚心接受并及时改进质量。

初始化列表

问题引导

因为初始化列表是构造函数的一部分，小编专门写了一篇构造函数供大家参考。

小编先抛给大家一个问题，有如下代码

class Time
{
public:
  Time(int huor, int miunte, int second)  //Time类的带参构造函数
  {
    _huor = huor;
    _minute = miunte;
    _second = second;
    cout << "Time带参数构造" << endl;
  }
private:
  int _huor;  //时
  int _minute;  //分
  int _second;  //秒
};
 
class Date
{
public:
  
 
private:
  int _year; //年
  int _month; //月
  int _day;  //日
  Time _t;  //时间类的对象
};

上述代码中， 定义了一个时间类Time和日期类Date。 时间类中定义了带参的构造函数 ，日期类并没有显式定义构造函数。时间类的对象_t是日期类的成员变量。那么，上述代码中有什么错误吗？

会在实例化日期类对象的时候报错。

这个报错有点抽象。造成这样报错的原因是：Date类在实例化对象时，系统会生成Date类默认的构造函数，该函数对内置类型不做处理，对自定义类型（_t）会调用该类型的默认构造函数，但我们并没有显式定义Time类的默认构造函数，而且Time类中有带参数的构造函数，所以系统也不会自动生成Time类的默认构造函数。

画图帮大家理解一下

上述问题的核心是：要么Time类没有显式的定义默认构造函数，要么不能通过Date类给Time类中的带参构造函数传参，导致自定义成员变量_t不能完成初始化。

如果在Time类中显式定义默认构造函数，这个问题自然就解决了。那我们能不能通过传参来解决呢？

至此，就要请出本篇的第一个重点：初始化列表

概念引导

在实例化对象对象时，编译器会调用构造函数给给成员变量赋一个初始值。此时，编译器的行为叫不叫初始化呢?答案是不叫。此时编译器的行为叫赋初值，就是给该成员变量一个值。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

写法

写法：冒号开头，逗号分隔，中间是成员变量，成员变量后跟括号，括号里给初始值或表达式

位置：构造函数的函数名和函数体之间

图像示例

代码示例

Date()
  :_year(2024)
  ,_month(4)
  ,_day(22)
  ,_t(7,3,0)
{
 
}

问题解决

既然我们能写出参数列表，就能在实例化Date类的时候给Time类的带参构造函数传参吗？

调试可知，初始化列表确实解决了传参问题

写法的细节

上述示例中我们是在无参构造函数名和函数体之间写的初始化列表，能不能再有参构造上写呢？答案是可以的如下代码

Date(int year, int month, int day, Time t) 
  :_year(year)
  ,_month(month)
  ,_day(day)
  ,_t(t) 
{
 
}

那可不可以函数体和初始化函数混着来呢？答案是可以的，为了方便，甚至可以不要Time类型的形参如下代码

Date(int year, int month, int day) 
:_day(day) 
,_t(7,3,0)
{
  _year = year;
  _month = month;
}

但不要把自定义类型_t写进函数体，因为我们是想在Date类中就能把参数传给Time类中的带参构造函数，所以_t必须写进初始化列表。

初始化列表传参是很自由的，可以传值，传表达式，也可以传个函数。如下代码

int fuc()
{
  return 2 + 3;
}
Date(int year, int month, int day)
  :_day(1 + 2 + 22 - 10)
  , _year(fuc()) 
,_t(7,3,0) 
{
  _month = month;
}

注意点

变量的初始化一定在初始化列表

如果显式的写了初始化列表，编译器会走写好的初始化列表。如果没有写，编译器会走默认生成的初始化列表，该初始化列表对内置类型不做处理，对自定义类型会调用该类型的默认构造函数

下面三个成员必须放在初始化列表

第一点在上面的内容中说明了。小编解析一下第二点和第三点，在创建引用变量的时候必须指定引用的对象，并且该指定不能被改变。const成员变量具有常性，不可被改变。观察一下就会发现这两类变量有且只有唯一一次被赋值的机会，就是在初始化的时候。而成员变量是在初始化列表初始化的，所以上述三类变量放在初始化列表。

因为每个成员变量只能初始化一次，所以成员变量在初始化列表只能出现一次。如果在初始化列表出现两次就会强制报错

成员变量在初始化列表中初始化的顺序是其在类中声明的顺序，而不是在初始化列表中的前后次序。小编为大家找来了一道面试题，看下大家能作对吗，代码如下

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  随机值

为了不影响大家的做题体验，小编画图解析，

所以答案是D，大家做对了吗

到此为止，恭喜你把本篇的硬骨头啃下了，下面小编会为大家讲解一下类和对象的其他语法

隐式类型转换

概念：不同的内置类型相互转换或者把内置类型转化为类类型

单参数隐式类型转换

如下代码

class Test  //定义一个类
{
 
public:
 
  Test(int a) //类的构造函数
    :_a(1) //初始化列表
  {
  }
 
private:
 
  int _a;  //私有数据_a
};
 
int main()
{
  Test t = 3;  //隐式类型转换
 
  return 0;
}

3是整型，t是类类型，很显然，把3转换成了类类型。这是怎么转换的呢？

其实，是编译器调用了test类的构造函数从而实例化了一个对象，这个对象叫做临时对象_a的值是3，临时对象具有常性。然后编译器会再调用拷贝构造，把临时对象拷贝给对象t。

画个图帮大家理解一下

如果在一个表达式中有连续的构造和拷贝构造，编译器会直接把拷贝构造优化掉。直接把整形3构造成t对象。因为编译器通过更小的消耗实现了相同的效果。但我们在语言层面不能把拷贝构造去掉。

多参数隐式类型转换

如下代码

class Test
{
 
public:
 
  Test(int a,int b,int c)  
    :_a(a)
    ,_b(b)
    ,_c(c)
  {
  }
 
private:
 
  int _a;
  int _b;
  int _c;
};
 
int main()
{
  Test t = { 2, 4, 6 };
 
  return 0;
}

在语法上，需要把多个参数用大括号括起来

Test t = { 2, 4, 6 };

explicit关键字

在构造函数的函数名前加上 explicit关键字，可以禁止隐式类型转换

如下代码

  explicit Test(int a,int b,int c)
    :_a(a)
    ,_b(b)
    ,_c(c)
  {
  }

此时就不能实现隐式类型转换了

static成员

概念

被static修饰的变量成为静态成员变量，被static修饰的函数成为静态成员函数。

特性

静态成员为所有类对象所共享，该成员存放在静态区

静态成员变量要在类外面定义。

对于变量而言，“定义”一词的界定应为变量是否开空间。在初始化就是在为变量开空间。静态成员是具有全局性的，不可能每次都实例化对象时都初始化该成员变量

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

如果静态成员时公有，可通过类名::静态成员  或  对象.静态成员访问。

静态成员函数没有隐藏的this指针，所以不能访问非静态成员。

友元

友元函数

一个普通的A函数如果在B类中声明并且在前面加上friend关键字，那么A函数就是B类的友元函数，A函数就可以访问B类的私有成员变量。如下代码，大家感受一下

class B
{
  friend void A(); //友元函数A
public:
 
private:
  int _a; //私有数据_a
};
 
void A()
{
  B b;
  cout << b._a<< endl;  //直接访问_a
}

友元函数的注意点

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员

友元关系是单向的

友元关系不能传递

B是A的友元，C是B的友元，不能说明C是A的友元

如下代码，帮助大家感受一下友元类

class Time //时间类
{
  friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成
  
public:
  
    Time(int hour = 0, int minute = 0, int second = 0) //构造函数
    : _hour(hour)
    , _minute(minute)  //参数列表
    , _second(second)
  {}
 
private:
  int _hour;  //时
  int _minute; //分
  int _second;  //秒
};
class Date  //日期类
{
public:
  Date(int year = 1900, int month = 1, int day = 1) //构造函数
    : _year(year)
    , _month(month)  //参数列表
    , _day(day)
  {}
 
  void SetTimeOfDate(int hour, int minute, int second)
  {
    // 直接访问时间类私有的成员变量
    _t._hour = hour;
    _t._minute = minute;
    _t._second = second;
    
  }
 
private:
  int _year;  //年
  int _month; //月
  int _day;  //日
  Time _t;  //时间类对象
};

内部类

如果把A类定义在B类内部，那么这个A类就是内部类。

但A类和B类是平行关系（如果计算外部类的大小，是算不到内部类的），唯一的联系就是，A类是B类的友元类。

内部类不受访问限定符限制，可以定义在外部类的任何位置

好啦，本篇的内容到此结束啦