c++基本使用（构造函数的初始化列表）

已于 2023-06-16 10:51:35 修改
阅读量576 收藏 4
点赞数
文章标签： c++ 开发语言
于 2023-03-07 14:07:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41701723/article/details/129381247
版权

构造函数的初始化列表

语法：

    CGirl(string name, int age, CBoy& boy) :m_name(name), m_age(age),m_boy(boy)      // 三个参数的普通构造函数。
    {
        cout << "调用了CGirl(name,age,boy)构造函数。\n";
    }
  1. 如果成员已经在初始化列表中，则不应该在构造函数中再次赋值。
  2. 初始化列表的括号中可以是具体的值，也可以是构造函数的形参名，还可以是表达式。
  3. 初始化列表与赋值有本质的区别，如果成员是类，使用初始化列表调用的是成员类的拷贝构造函数，而赋值则是先创建成员类的对象（将调用成员类的普通构造函数），然后再赋值。
  4. 如果成员是类，初始化列表对性能略有提升。
  5. 如果成员是常量和引用，必须使用初始列表，因为常量和引用只能在定义的时候初始化。
  6. 如果成员是没有默认构造函数的类，则必须使用初始化列表。
  7. 拷贝构造函数也可以有初始化列表。
  8. 类的成员变量可以不出现在初始化列表中。
  9. 构造函数的形参先于成员变量初始化。

1的例子：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。



class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                     // 姓名属性。
    int         m_age;                         // 年龄属性。
    CGirl():m_name("西施"),m_age(22)                                       // 没有参数的普通构造函数，默认构造函数。  
    {  
        m_name="赋值后的西施";
        cout << "调用了CGirl()构造函数。\n"; 
    }
    //CGirl(string name, int age,CBoy &boy)     // 三个参数的普通构造函数。
    //{
    //    m_name = name; m_age = age; m_boy.m_xm = boy.m_xm;
    //    cout << "调用了CGirl(name,age,boy)构造函数。\n";
    //}
    CGirl(string name, int age) :m_name(name), m_age(age)   // 三个参数的普通构造函数。
    {
        cout << "调用了CGirl(name,age,boy)构造函数。\n";
    }
    // 超女自我介绍的方法，显示姓名、年龄、男朋友。
    void show() { cout << "姓名：" << m_name << "，年龄：" << m_age << endl; }
};

int main()
{
    CGirl g1;
    
    g1.show();
}

2的例子：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。


class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                     // 姓名属性。
    const int         m_age;                         // 年龄属性。

    //CGirl()                                       // 没有参数的普通构造函数，默认构造函数。  
    //{  
    //    cout << "调用了CGirl()构造函数。\n"; 
    //}
    //CGirl(string name, int age,CBoy &boy)     // 三个参数的普通构造函数。
    //{
    //    m_name = name; m_age = age; m_boy.m_xm = boy.m_xm;
    //    cout << "调用了CGirl(name,age,boy)构造函数。\n";
    //}
    CGirl(string name, int age) :m_name(name), m_age(age+100)     // 三个参数的普通构造函数。
    {
        cout << "调用了CGirl(name,age,boy)构造函数。\n";
    }
    // 超女自我介绍的方法，显示姓名、年龄、男朋友。
    void show() { cout << "姓名：" << m_name << "，年龄：" << m_age << endl; }
};

int main()
{
    
    CGirl g1("冰冰",18);
    
    g1.show();
}

3的例子：
使用初始化列表，

  1. 先调用的是成员类的拷贝构造函数，
  2. 而赋值则是先创建成员类的对象（将调用成员类的普通构造函数），
  3. 然后再赋值

总结就是：先初始化构造函数的形参对象boy（使用拷贝构造函数，从实参对象CBoy boy("子都");拷贝过来），然后初始化类成员（使用普通构造函数初始化类成员m_boy）

区分了（数据传递的方向是）实参–>形式参数–>类成员

拷贝构造函数
这一篇博文保姆级详细的解释了这个传参中，构造函数调用的问题

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

class CBoy                // 男朋友类。
{
public:
    string m_xm;                      // 男朋友的姓名。
    CBoy()                                 // 没有参数的普通构造函数，默认构造函数。  
    { m_xm.clear();  cout << "调用了CBoy()构造函数。\n"; }
    CBoy(string xm)                 // 有一个参数的普通构造函数。  
    { m_xm = xm;  cout << "调用了CBoy(string xm)构造函数。\n"; }
    CBoy(const CBoy& bb)     // 默认拷贝构造函数。  
    { m_xm = bb.m_xm;  cout << "调用了CBoy(const CBoy &bb)拷贝构造函数。\n"; }
};

class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                     // 姓名属性。
    int         m_age;                         // 年龄属性。
    CBoy     m_boy;                         // 男朋友的信息。

    CGirl()                                       // 没有参数的普通构造函数，默认构造函数。  
    {  
       cout << "调用了CGirl()构造函数。\n"; 
    }

    CGirl(string name, int age, CBoy boy) :m_name(name), m_age(age)      // 三个参数的普通构造函数。
    {
        m_boy.m_xm = boy.m_xm;
        cout << "调用了CGirl(name,age,boy)构造函数。\n";
    }
    // 超女自我介绍的方法，显示姓名、年龄、男朋友。
    void show() { cout << "姓名：" << m_name << "，年龄：" << m_age << "，男朋友：" << m_boy.m_xm << endl; }
};

int main()
{
    CBoy boy("子都");

    CGirl g1("冰冰",18,boy);
    
    g1.show();
}

将构造函数中的类形参改为引用，则不调用拷贝构造函数了
（省去了之前实参向形参传值调用的那个拷贝构造函数）

    CGirl(string name, int age, CBoy& boy) :m_name(name), m_age(age)      // 三个参数的普通构造函数。
    {
        m_boy.m_xm = boy.m_xm;
        cout << "调用了CGirl(name,age,boy)构造函数。\n";
    }

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

class CBoy                // 男朋友类。
{
public:
    string m_xm;                      // 男朋友的姓名。
    CBoy()                                 // 没有参数的普通构造函数，默认构造函数。  
    { m_xm.clear();  cout << "调用了CBoy()构造函数。\n"; }
    CBoy(string xm)                 // 有一个参数的普通构造函数。  
    { m_xm = xm;  cout << "调用了CBoy(string xm)构造函数。\n"; }
    CBoy(const CBoy& bb)     // 默认拷贝构造函数。  
    { m_xm = bb.m_xm;  cout << "调用了CBoy(const CBoy &bb)拷贝构造函数。\n"; }
};

class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                     // 姓名属性。
    int         m_age;                         // 年龄属性。
    CBoy     m_boy;                         // 男朋友的信息。

    CGirl()                                       // 没有参数的普通构造函数，默认构造函数。  
    {  
       cout << "调用了CGirl()构造函数。\n"; 
    }

    CGirl(string name, int age, CBoy& boy) :m_name(name), m_age(age)      // 三个参数的普通构造函数。
    {
        m_boy.m_xm = boy.m_xm;
        cout << "调用了CGirl(name,age,boy)构造函数。\n";
    }
    // 超女自我介绍的方法，显示姓名、年龄、男朋友。
    void show() { cout << "姓名：" << m_name << "，年龄：" << m_age << "，男朋友：" << m_boy.m_xm << endl; }
};

int main()
{
    CBoy boy("子都");

    CGirl g1("冰冰",18,boy);
    
    g1.show();
}

使用初始化列表，则：初始化类成员调用拷贝构造函数了
（之前没有使用初始化列表，初始化类成员调用普通构造函数。。）

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

class CBoy                // 男朋友类。
{
public:
    string m_xm;                      // 男朋友的姓名。
    CBoy()                                 // 没有参数的普通构造函数，默认构造函数。  
    { m_xm.clear();  cout << "调用了CBoy()构造函数。\n"; }
    CBoy(string xm)                 // 有一个参数的普通构造函数。  
    { m_xm = xm;  cout << "调用了CBoy(string xm)构造函数。\n"; }
    CBoy(const CBoy& bb)     // 默认拷贝构造函数。  
    { m_xm = bb.m_xm;  cout << "调用了CBoy(const CBoy &bb)拷贝构造函数。\n"; }
};

class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                     // 姓名属性。
    int         m_age;                         // 年龄属性。
    CBoy     m_boy;                         // 男朋友的信息。

    CGirl()                                       // 没有参数的普通构造函数，默认构造函数。  
    {  
       cout << "调用了CGirl()构造函数。\n"; 
    }

    CGirl(string name, int age, CBoy& boy) :m_name(name), m_age(age),m_boy(boy)      // 三个参数的普通构造函数。
    {
        // m_boy.m_xm = boy.m_xm;
        cout << "调用了CGirl(name,age,boy)构造函数。\n";
    }
    // 超女自我介绍的方法，显示姓名、年龄、男朋友。
    void show() { cout << "姓名：" << m_name << "，年龄：" << m_age << "，男朋友：" << m_boy.m_xm << endl; }
};

int main()
{
    CBoy boy("子都");

    CGirl g1("冰冰",18,boy);
    
    g1.show();
}

5的例子：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

class CBoy                // 男朋友类。
{
public:
    string m_xm;                      // 男朋友的姓名。
    CBoy()                                 // 没有参数的普通构造函数，默认构造函数。  
    { m_xm.clear();  cout << "调用了CBoy()构造函数。\n"; }
    CBoy(string xm)                 // 有一个参数的普通构造函数。  
    { m_xm = xm;  cout << "调用了CBoy(string xm)构造函数。\n"; }
    CBoy(const CBoy& bb)     // 默认拷贝构造函数。  
    { m_xm = bb.m_xm;  cout << "调用了CBoy(const CBoy &bb)拷贝构造函数。\n"; }
};

class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                     // 姓名属性。
    const int         m_age;                         // 年龄属性。
    CBoy&     m_boy;                         // 男朋友的信息。

    // CGirl(string name, int age, CBoy& boy)      // 三个参数的普通构造函数。
    // {
    //     m_name = name;
    //     m_age = age;
    //     m_boy.m_xm = boy.m_xm;
    //     cout << "调用了CGirl(name,age,boy)构造函数。\n";
    // }
    CGirl(string name, int age, CBoy& boy):m_name(name),m_age(age),m_boy(boy)      // 三个参数的普通构造函数。
    {
        cout << "调用了CGirl(name,age,boy)构造函数。\n";
    }
    // 超女自我介绍的方法，显示姓名、年龄、男朋友。
    void show() { cout << "姓名：" << m_name << "，年龄：" << m_age << "，男朋友：" << m_boy.m_xm << endl; }
};

int main()
{
    CBoy boy("子都");

    CGirl g1("冰冰",18,boy);
    
    g1.show();
}

类形参改为引用，则不调用拷贝构造函数了
类成员改为引用，则不调用拷贝构造函数了（使的是初始化列表）
在这里插入图片描述

如果都不使用引用，则是如下的结果：

在这里插入图片描述

在这里插入图片描述

计算机CV民工
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 构造函数初始化列表的好处
12-22
　Derive 类构造函数两个 Base 类型的参数，分别赋给该类两个 Base 类型的成员变量 b1、b2，一个使用初始化列表，一个使用等于号赋值。输出结果如下： 　前两行输出是主函数前两行构造 b1、b2 对像时调用的带...
C++类构造函数初始化列表
12-22
构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式。例如： class CExample { public: int a; float b; //构造函数初始化列表 CExample(): a(0...
【C++】c++中的六个默认函数——构造函数
区柒大人的博客
12-02 1314
类的6个默认的成员函数包括： 构造函数、析构函数、拷贝构造函数、赋值运算符重载函数、取地址操作符重载、const修饰的取地址操作符重载。（但是重点讲前四个）   构造函数（可以重载） 在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能手动调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）。 class ...
C++基础3 类:构造 拷贝 析构函数 静态变量函数 const初始化列表 new delete this 面向对象模型...
weixin_34199405的博客
06-29 159
今天的知识内容：1）为什么会出现构造函数与析构函数构造函数3种初始化2）拷贝函数4种应用时机【新发现】在拷贝构造函数里面 可以直接访问私有成员属性两个已经初始化完毕的对象 用= 号赋值不会调用构造函数3）匿名对象的去与留GCC 与 VS环境编译的差异一旦自定义了构造函数，你必须去调用4）【强化】构造函数 与 析构函数的执行顺序强化练习对象中包含有其他对象时，先初始化别人，再...
C++入门-构造函数初始化列表
最新发布
Choulqt的博客
03-01 618
大家好啊，今天我们来聊聊在C++中的构造函数初始化列表。在C++中，构造函数初始化列表是一种特殊的语法，用于在创建对象时对成员变量进行初始化。它可以提高代码的效率和可读性，尤其在处理类中的常量成员、引用成员或基类构造函数参数时非常有用。本篇博客将介绍构造函数初始化列表的知识点，并通过例子和代码来解释每个知识点。
c++深拷贝、浅拷贝、构造函数初始化列表
tulipless的博客
05-28 636
#define _CRT_SECURE_NO_WARNINGS//一定要加在最前面#include &lt;iostream&gt;using namespace std;//对象谁先构造谁后析构class Teacher{public:    Teacher(int id, const char *name)    {        my_id = id;        int len = st...
构造函数中的初始化列表，以及构造函数和析构函数的调用顺序
凡辰道
04-01 1000
新学到了C++里新的初始化方法，初始化列表。因此来整理一下。若有错漏，还望指摘。 构造函数 构造函数可分为普通构造函数和拷贝构造函数。 普通构造函数 构造函数就是在类实例化时，自动调用来生成类的函数。若未定义，则系统自动生成。比如： class test{}; test A; 在实例化A的时候就会调用普通构造函数。 形式为函数名与类名相同，没有也不能声明任何类型的返回值。 拷贝构造函数 ...
【C++】构造函数初始化列表
qq_35902025的博客
10-12 3247
C++构造函数初始化列表
c++ 构造函数的初始化列表
12-31
首先，运行下图中的C++代码，输出是什么？ 代码如下:class A{private: int n1; int n2;public: A(): n2(0) , n1(n2 + 2) { } void Print() {  cout<<“n1:”<<n1<<“,n2:”<<n2<<endl; }};int main(void){ A a; a.Print(); return 0;}答案：输出n1是一个随机的数字，n2为0。在C++中，成员变量的初始化顺序与变量在类型中的声明顺序相同，而与它们在构造函数的初始化列表中的顺序无关。因此在这道题中，会首先初始化n1，而初始n1的参数n2还没有初始化，是
C++学习之路-构造函数的初始化列表
weixin_45452278的博客
05-20 9731
初始化列表何为初始化列表初始化列表的本质初始化列表的优势初始化列表中列表顺序问题初始化列表与默认参数的配合使用初始化列表的注意之处构造函数的声明和实现分离时，初始化列表需写在实现里子类调用父类的构造函数初始化列表总结 何为初始化列表 定义：一种便捷的初始化类内成员变量的方式。 初始化成员变量通常在构造函数里执行，如下例所示。成员变量的初始化可以通过调用有参的构造函数进行传参初始化，也可以通过调用无参的构造函数在函数体内部直接初始化（可以看我之前的博文）。下例展示了调用有参的构造函数始化成员变量的方式。
c++的构造函数初始化列表
u011555996的博客
08-24 1758
C++类构造函数初始化列表 构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式。例如： class CExample { public: int a; float b; //构造函数初始化列表 CExample(): a(0),b(8.8) {} //构造函数内部赋值 CExample() { a=0; b=8
C++构造函数之初始化列表
长岛冰茶去冰的博客
03-04 6156
C++构造函数的初始化列表详解
C++ | 谈谈构造函数的初始化列表
做技术人 · 产优质博客 · 找好工作
04-04 3027
面对无法构造成功的一些成员变量，例如：常变量（const），看看C++是怎么做的👈
c++ 子类构造函数初始化及父类构造初始化的使用
08-18
主要介绍了c++ 子类构造函数初始化及父类构造初始化的使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
c++基础语法:构造函数初始化列表
01-20
它本身是一个类或者是一个结构，而且这个成员它只有一个带参数的构造函数，而没有默认构造函数，这时要对这个类成员进行初始化，就必须调用这个类成员的带参数的构造函数，如果没有初始化列表，那么他将无法完成第一...
c++ 构造函数详解
热门推荐
若尘的博客
05-31 4万+
c++构造函数详解。（构造函数的分类、拷贝构造函数）
构造函数的多种初始化方式
gjg244的博客
02-14 2643
C++构造函数
在C++拷贝构造函数中使用初始化列表
justin12zhu的专栏
06-26 4692
今天同事遇到一个关于拷贝构造函数的问题。代码大致如下： class test { public: test( size_t size ) { v.assign( size, 1 ); } test( const test& rhs) { v = rhs.v; } ~test(){} private: vector v; }; class anot
c++的构造函数种类大全
weixin_48617416的博客
04-06 1452
从语法上讲，构造函数是与类同名的函数。功能是用于初始化数据成员。构造函数没有返回类型，参数可以有，也可以没有，没有参数的构造函数称为，也称为无参构造函数。有些情况下，必须提供默认的构造函数，否则就会编译报错。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值