C嘎嘎~~[构造函数提升篇]

1. 再谈构造函数

1.1. 引入

1.1.1问题引入

class Date
{
public:
private:
  int _year;
  int _month;
  int _day;
};

通过前面所学的知识, 我们知道了_year, _month, _day这三个变量都是一些声明, 并没有开辟空间, 不是定义.

Date d1;

这一个操作就是给 d1这个对象整体定义, 但是对象整体定义,并不代表着里面的三个成员变量定义了.

🗨️那么问题来了: 成员变量是在什么时候定义的??

1.1.2 const引入

class Date
{
public:
private:
  int _year;
  const int _month;
  int _day;
};
int main()
{
  Date d1;
  return 0;
}

当我们用const 来修饰一下其中的一个成员变量, 那么会怎么样了?

🗨️这样的报错是什么意思? — 具有未初始化的常量限定数据成员

其实我们可以发现一些端倪: 就是const 修饰的变量有一个特点就是 定义的时候一定要初始化, 那么有些老铁就会说 在里面给 const修饰的变量一个缺省值试一试

🗨️这些不是声明嘛, 给一个缺省值为什么就可以了? 原理是什么啊? 还有就是传一个缺省值是传给谁啊?

其实, 初始化列表可以看成成员变量定义的地方. 而我们给的缺省值也是给初始化列表用的. 缺省, 缺省, 说实话就是一个备胎, 如果我们在初始化列表中给了这个变量的值⇒ 那么就不会用这个缺省值了, 而去用我们在初始化列表中的值.

1.2 正篇

在构造函数中,初始化成员变量有两种方式: 构造函数体赋值 和 初始化列表

其实, 这两种方式是有所不同的, 通过下面的一些比较就能看出他们的不同

1.2.1 构造函数体赋值

class Date
{
public:
  Date(int year, int month, int day)
  {
    _year = year;
    _year = 2022;
    _month = month;
    _month = 5;
    _day = day;
    _day = 20;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1(2023, 5, 16);
  return 0;
}

🗨️延续上面的问题, 这个是不是初始化?

其实答案很明显, 这个是并不是初始化. 因为每一个变量只有一次初始化, 但是可以有多次赋值. 通过上面的代码, 我们可以发现: 在构造函数内部可以进行多次的赋值, 而初始化只有一次, => 构造函数不是成员变量初始化的地方

1.2.2 初始化列表

1.2.3.1 浅浅认识

初始化列表: 以一个冒号开始, 接着用一个逗号 去分隔数据成员列表, 每一个 成员变量后面跟一个放在括号中的初始值或者表达式

class Date
{
public:
    // 构造函数
  Date()
       // 此部分是 初始化列表
    :_year(2023)
    // 此部分是 构造函数体赋值
  {
    _month = 5;
    _day = 16;
  }
private:
  const int _year; // const 修饰的成员变量
  int _month;
  int _day;
};
int main()
{
  Date d1;
  return 0;
}

注意:

1.每个成员变量在初始化列表中 最多出现一次(因为只能初始化一次)

2.类中包含以下的成员时, 必须放在初始化列表中进行初始化:

const 修饰的成员变量

引用修饰的成员变量

没有默认构造函数的自定义类型

1.2.3.2 构造函数的 行走顺序

构造函数初始化成员变量有两种形式: 构造函数体赋值 和 初始化列表

一个是 赋值, 一个是 初始化 ⇒ 由此不难看出, 编译器先走的是 初始化列表然后才是构造函数体赋值

🗨️如果没有初始化列表, 编译器会走初始化列表这一步吗?

猛一看, 感觉这个问题是不是有问题; 仔细一想, 其实这个问题问的很有深度~~. 换一句话说, 其实这个问题是想问 ⇒ 初始化列表是构造函数必走的一步吗?

通过下面的代码, 验证一番:

class Date
{
public:
  Date()
  {
    _month = 5;
    _day = 16;
  }
  void Print()
  {
    cout << _year << " " << _month << " " << _day << endl;
  }
private:
  const int _year = 5;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  d1.Print(); // 5 5 16
  return 0;
}

class Date
{
public:
  Date()
    :_year(2023)
  {
    _month = 5;
    _day = 16;
  }
  void Print()
  {
    cout << _year << " " << _month << " " << _day << endl;
  }
private:
  const int _year = 5;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  d1.Print(); //2023 5 16
  return 0;
}

通过上面的两个例子:

1.补丁 — — 成员变量给个缺省值, 这个缺省值其实传给初始化列表的. 如果初始化列表没有对此变量进行操作, 那么就会使用那个缺省值

2.初始化列表是构造函数必走的一步 — — 因为初始化列表是成员变量定义的地方

1.2.3.3 引用修饰成员变量

class A
{
public:
  A(int a, int& b)
  {
    _a1 = a;
    _a2 = b;
  }
private:
  int _a1;
  int& _a2;
};
int main()
{
  int n = 10;
  A a(10, n);
  return 0;
}
*****
error C2530: “A::_a2”: 必须初始化引用
*****

🗨️有一些老铁, 就会有一些疑问: 为什么这里的传引用不能传递一个常量⇒ 就比如 A a(10, 10);

首先这样写会有报错的:

在这里, 我们只需要看一下红色的报错(蓝色的报错是这一类 的错误 — — 不能用构造函数体赋值来初始化 用引用修饰的成员变量):

因为 _a2 是 b的引用, b 是 10的引用 ⇒ _a2 是 10的引用, 由于 10是一个常量, 所以引用都要用常量引用来接收, 否则就是引用的权限放大造成错误!!!

如果我们这样修改的话, 就必须把成员变量里面也用 const来修饰此变量才可以. 不过这样多不方便⇒ 传一个常量, 一直用, 还不能改变⇒ 这不符合我们的需求啊~

通过上面的例子, 我们发现: 使用构造函数体赋值这种方式是不行的!!

那么, 我们就采用初始化列表:

_a2 = 10 — — _a2 是 b的引用, b 是 n的引用 ⇒ _a2 是 n的引用. 因为初始化列表是成员变量定义的地方, 所以可以在此处进行对 引用修饰的_a2 进行初始化

_a1 是一个随机值 — — 发现传参的 10没用⇒ 想告诉各位读者的是, 我们传参是有自己的目的性 和 选择性; 如果我们不用, 对于内置类型成员变量(当然也没有缺省值)就会被初始化为随机值.

1.2.3.4 没有默认构造的自定义类型

class B
{
public:
  // 无参调用 ==> 默认构造
  B()
  {
  }
private:
  int _b;
  int _tem;
};
class A
{
public:
private:
  int _a;
  B bb;
};
int main()
{
  A a1;
  return 0;
}

上面的代码是正确的, 因为A 类中有一个自定义类型的成语变量 bb. 构造函数是完成成员变量的初始化的, 对于 A类来说, 要完成 对 _a 和 bb( _b _tem) 的初始化. 而要完成对 bb的初始化, 就需要 B类的默认构造. 如果 B类存在默认构造, 那么就会对 bb 进行初始化, 如果 B类不存在默认构造, 那么就不会对 bb进行初始化.👇👇👇

class B
{
public:
  // 有参 ==> 就不存在默认构造
  B(int x, int y)
  {
    _b = x;
    _tem = y;
  }
private:
  int _b;
  int _tem;
};
class A
{
public:
private:
  int _a;
  B bb;
};
int main()
{
  A a1;
  return 0;
}

上面, 我们故意对 B类的构造函数写成了有参调用⇒ 那么 B类就会失去默认构造=> B(_b _ tem) 就会是随机值, 就不能完成对 B(_b _ tem) 的初始化了=> A类中就不能完成初始化

那我们试一试初始化列表👇👇👇

对自定义类型成员变量的初始化总结:

1.2.3初始化列表的 '坑'

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

class A
{
public:
  A(int a)
    :_a1(a)
    ,_a2(_a1)
  {}
private:
  int _a2;
  int _a1;
};
int main()
{
  A a(1);
}

🗨️上面代码的运行结果是什么?

_a2 是随机值, _a1 = 1

因为声明中的顺序是 _a2 _a1, 那么编译器在初始化列表初始化的时候就会 先初始化 _a2, 再初始化_a1 ⇒

初始化 _a2 的时候: _a2( _a1), 这时候_a1还没有被初始化, 所以是一个随机值; 初始化 _a1的时候: _a1(1), 那么 _a1就是 1喽

建议— — 尽量按照声明的顺序来安排初始化列表中变量的初始化顺序

初始化列表中, 每一个成员变量最多只能出现一次

class A
{
public:
  A()
    :_a1(5)
    ,_a2(10)
    ,_a1(8)
  {}
private:
  int _a2;
  int _a1;
};
int main()
{
  A a;
  return 0;
}

初始化列表是每个成员变量定义的地方, 也是初始化的地方

1.2.4 谈谈初始化列表 和 构造函数

其实, 每一个初学者在这个地方都会停留一段时间.

初始化列表 和 构造函数, 一不留神就会混淆了概念和作用

总的来说, 初始化列表是构造函数的一部分.构造函数的功能就是完成对成员变量的初始化工作, 对自定义类型会调用它的默认构造, 而对于内置类型, 就不会进行处理.

完成这一个初始化工作, 有两个方式: 初始化列表 和 构造函数体赋值. 见名知义: 一个是初始化, 一个是赋值.

如果成员变量中 没有 const修饰, 引用修饰 或者 没有默认构造的自定义类型, 写不写初始化列表都是ok的, 只要有其中的一个存在, 就要写一下初始化列表. 其实const修饰的成员变量也可以不用写初始化列表(上面有例子, 不清楚的上去看看)

比较来说, 初始化列表可以完成的工作 > 构造函数体赋值 ⇒ 我们一般建议使用初始化列表. 当然有些工作时需要构造函数体赋值, 也是要写构造函数体赋值的.

1.3 explicit关键字

1.3.1 引入

前面C语言的学习, 我们知道存在一种 类型转换. 由于C++能够兼容C语言, 我们就大胆实验👇👇👇

class A
{
public:
  A(int a)
    :_a(a)
  {}
private:
  int _a;
};
int main()
{
  A a = 23;
  return 0;
}

上面的代码是可行的.

🗨️为什么可以直接从一个 int类型直接转换成 A类的对象a呢?? 中间出现了什么过程呢??

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

1.3.2 正篇

1.3.2.1 赋值的含义

🗨️先有一个问题: 在C语言的学习中, 以int a = 10; double b = a; 为例子, 讲述一下 类型转换的过程

类型转换不是直接就 把 a 的值 赋值给 b. 会生成一个 类型为 double的临时变量, 记作 tem , 然后把tem 赋值给 b . 这里多说一句, 后面就出现了引用 &, 就不会有临时对象的生成.

那么延续上面的思路, 我们就会知道上面代码的一个原理:

用 23去构造了一个 类型为A的临时对象, 记作tem, 然后把 tem 拷贝构造给 a

🗨️为啥换到这里就是 构造 和 拷贝构造了??

生成一个类型是 A的临时对象 tem, 用 23去初始化tem — — 构造

用一个已知的对象tem 去初始化另一个对象 a — — 拷贝构造

1.3.2.2 探寻 '隐式类型转换' 的真相

我们已经知道隐式类型转换的一个原理, 那么用代码来验证一番:

class A
{
public:
  A(int a)
    :_a(a)
  {
    cout << "调用了构造函数" << endl;
  }
  A(const A& x)
  {
    cout << "调用了拷贝构造函数" << endl;
  }
private:
  int _a;
};
int main()
{
  A a = 23;
  return 0;
}
*****
调用了构造函数
*****

🗨️嗯??, 跟我们想的不一样, 难道我们想错了??

其实不然, 这里编译器把它给优化了.

我们知道: 构造 和 拷贝构造 的功能都是 初始化, 如果在同一行, 我们同时调用 构造 + 拷贝构造 ⇒ 编译器就只会调用一个构造函数, 直接完成赋值~~

🗨️老陈, 你空口无凭, 给我们看一下证据??

ok, 这就安排

由于,临时对象具有常性, 所以我们想到了用 引用 &来进行验证 <== 因为权限可以缩小 或 平移, 但是不能放大

先看下面的代码👇👇👇

class A
{
public:
  A(int a)
    :_a(a)
  {
    cout << "调用了构造函数" << endl;
  }
  A(const A& x)
  {
    cout << "调用了拷贝构造函数" << endl;
  }
private:
  int _a;
};
int main()
{
  A& a = 23;
  return 0;
}
*****
error C2440: “初始化”: 无法从“int”转换为“A &”
*****

class A
{
public:
  A(int a)
    :_a(a)
  {
    cout << "调用了构造函数" << endl;
  }
  A(const A& x)
  {
    cout << "调用了拷贝构造函数" << endl;
  }
private:
  int _a;
};
int main()
{
  const A& a = 23;
  return 0;
}
*****
调用了构造函数
*****

这里就变相地证明了: 上面的隐式类型转换 是经历过了构造 + 拷贝构造, 不过是编译器有优化而已

注意: 不同的编译器有不同的优化, 所以看到不同的结果不必大惊小怪的~~

1.3.2.3 explicit关键字

在一些场景下, 隐式类型转换会很方便(后面会学到的 string, STL… …),

但在另一些场景下, 我们又不希望隐式类型转换的出现(后面会学到的 智能指针… …)

那我们如何不让 隐式类型转换 发生呢?? — — 答案就是explicit关键字

把explicit 放在 构造函数的前面就会不让 隐式类型转换发生

class A
{
public:
  explicit A(int a)
    :_a(a)
  {
    cout << "调用了构造函数" << endl;
  }
  A(const A& x)
  {
    cout << "调用了拷贝构造函数" << endl;
  }
private:
  int _a;
};
int main()
{
  A a = 23;
  return 0;
}
*****
error C2440: “初始化”: 无法从“int”转换为“A”
message : class“A”的构造函数声明为“explicit”
*****

大鹏一日同风起，扶摇直上九万里