【C++】3.构造函数与析构函数（下）

已于 2024-05-06 17:46:29 修改
阅读量901 收藏 5
点赞数 25
分类专栏： 杂 文章标签： c++
于 2024-05-06 01:34:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hlyd520/article/details/138478583
版权

文章目录

3.2析构函数

是一种特殊的函数，主要作用是在对象生命周期结束的时候进行清理。

系统可以自动调用析构函数

析构函数语法规则：

  1. 函数名与类目相同，在前面加上1个~

  2. 没有返回值类型和返回值，也没有参数

  3. 有低保：没写的话，系统给个默认的

看起来这样：

class MyClass {
public:
    int id;
};

int main() {
    MyClass obj_0;
    obj_0.~MyClass();

    return 0;
}

实际上这样：

class MyClass {
public:
    MyClass();
    ~MyClass();
private:
};

MyClass::MyClass() {}
MyClass::~MyClass() {}

int main() {
    MyClass obj_0;
    obj_0.~MyClass();

    return 0;
}

在这里插入图片描述

  1. 析构函数可以主动通过对象 调用 。
  2. 析构函数必须是共有属性下。
  3. 在对象生命周期结束时，系统会自动调用析构函数。
  4. 任何一个类都只可能有1个析构函数。（因为函数名确定了，参数表要求是空的，这两个东西都定下来了就不会产生重载了）

不是因为调用了析构函数导致生命周期结束，是生命周期结束时，会自动调用析构函数。

3.3拷贝构造函数

拷贝构造是一种特殊的构造函数，通过拷贝构造函数完成一个复制的过程。

从一个对象得到另一个相同的对象。

特殊在这个类型的函数的参数是本类的对象的引用。

他的第一个函数（最前面的参数）是当前这个类的对象的引用。

不是说拷贝了构造函数，这种说法是错误的！！！

先是一个构造函数，才有可能是拷贝构造函数。

拷贝构造函数有低保：没写系统给，将成员一一对应 赋值。

也可以自定义。

目前3个低保：

class MyClass {
    MyClass(){}//默认的构造函数
    ~MyClass(){}//默认的析构函数
    MyClass(const MyClass& obj){}//默认的拷贝构造函数
};

class MyClass {
    MyClass(){}//默认的构造函数
    ~MyClass(){}//默认的析构函数
    MyClass(const MyClass& obj) {}//默认的拷贝构造函数
    MyClass(const MyClass& obj, int n, int m) {}//可以重载的，也是拷贝构造函数
    MyClass(int n, const MyClass& obj, int m) {}//不是拷贝构造函数,因为这个的第一个参数不是这个类的对应的参数的引用
};

int main() {

    return 0;
}

class Monster {
public:
    string m_name;
    int m_hp;
    float m_speed;

public:
    Monster();
    Monster(char* name, int hp, float speed);
    Monster(const Monster& obj);//拷贝构造
    Monster(const Monster& obj, int val);//拷贝构造重载
    ~Monster();

    void showData();

private:
};

Monster::Monster() {
    cout << "无参构造" << endl;
    m_name = "名字";
    m_hp = 100;
    m_speed = 10.0f;
}
Monster::Monster(char* name, int hp, float speed) {
    cout << "有参构造" << endl;
    m_name = name;
    m_hp = hp;
    m_speed = speed;
}
Monster::Monster(const Monster& obj) {
    cout << "拷贝构造1号" << endl;
    m_name = obj.m_name;
    m_hp = obj.m_hp;
    m_speed = obj.m_speed;
}
Monster::Monster(const Monster& obj, int val) {
    cout << "拷贝构造2号" << endl;
    m_name = obj.m_name;
    m_hp = val;
    m_speed = obj.m_speed;
}
Monster::~Monster() {
    cout << "析构函数" << endl;
}
void Monster::showData() {
    cout << "角色名字：" << m_name << endl;
    cout << "当前血量：" << m_hp << endl;
    cout << "移动速度：" << m_speed << endl;
    cout << "****************" << endl << endl;
}

int main() {
    Monster m0;
    Monster m1((char*)"皮卡丘", 120, 6.5f);
    Monster m2 = m0;//调用拷贝构造1号
    Monster m3(m0);//调用拷贝构造1号
    Monster m4(m1, 180);//调用拷贝构造2号

    Monster* p = new Monster;//调用无参构造，因为没传参数//这个要主动调用才会调用析构
    //所以一共调用6次构造只会有5次析构

    m0.showData();
    m1.showData();
    m2.showData();
    m3.showData();
    m4.showData();
    p->showData();

    return 0;
}

拷贝构造调用时机：

  1. 使用一个对象给另一个对象进行初始化

  2. 使用一个对象构造另一个对象

  3. 函数的参数是类的对象

  4. 函数的返回值是类的对象

class Monster {
public:
    string m_name;
    int m_hp;
    float m_speed;

public:
    Monster();
    Monster(char* name, int hp, float speed);
    Monster(const Monster& obj);//拷贝构造
    Monster(const Monster& obj, int val);//拷贝构造重载
    ~Monster();

    void showData();

private:

};

Monster::Monster() {
    cout << "无参构造" << endl;
    m_name = "名字";
    m_hp = 100;
    m_speed = 10.0f;
}
Monster::Monster(char* name, int hp, float speed) {
    cout << "有参构造" << endl;
    m_name = name;
    m_hp = hp;
    m_speed = speed;
}
Monster::Monster(const Monster& obj) {
    cout << "拷贝构造1号" << endl;
    m_name = obj.m_name;
    m_hp = obj.m_hp;
    m_speed = obj.m_speed;
}
Monster::Monster(const Monster& obj, int val) {
    cout << "拷贝构造2号" << endl;
    m_name = obj.m_name;
    m_hp = val;
    m_speed = obj.m_speed;
}
Monster::~Monster() {
    cout << "析构函数" << endl;
}
void Monster::showData() {
    cout << "角色名字：" << m_name << endl;
    cout << "当前血量：" << m_hp << endl;
    cout << "移动速度：" << m_speed << endl;
    cout << "****************" << endl << endl;
}

void test_func_1(Monster obj) {

}

int main() {
    Monster m0;
    Monster m1((char*)"皮卡丘", 120, 6.5f);

    test_func_1(m1);

    return 0;
}

在这里插入图片描述

class Monster {
public:
    string m_name;
    int m_hp;
    float m_speed;

public:
    Monster();
    Monster(char* name, int hp, float speed);
    Monster(const Monster& obj);//拷贝构造
    Monster(const Monster& obj, int val);//拷贝构造重载
    ~Monster();

    void showData();

private:

};

Monster::Monster() {
    cout << "无参构造" << endl;
    m_name = "名字";
    m_hp = 100;
    m_speed = 10.0f;
}
Monster::Monster(char* name, int hp, float speed) {
    cout << "有参构造" << endl;
    m_name = name;
    m_hp = hp;
    m_speed = speed;
}
Monster::Monster(const Monster& obj) {
    cout << "拷贝构造1号" << endl;
    m_name = obj.m_name;
    m_hp = obj.m_hp;
    m_speed = obj.m_speed;
}
Monster::Monster(const Monster& obj, int val) {
    cout << "拷贝构造2号" << endl;
    m_name = obj.m_name;
    m_hp = val;
    m_speed = obj.m_speed;
}
Monster::~Monster() {
    cout << "析构函数" << endl;
}
void Monster::showData() {
    cout << "角色名字：" << m_name << endl;
    cout << "当前血量：" << m_hp << endl;
    cout << "移动速度：" << m_speed << endl;
    cout << "****************" << endl << endl;
}

void test_func_1(Monster obj) {

}
Monster test_func_2() {
    Monster obj;
    return obj;
}

int main() {
    test_func_2();

    return 0;
}

Monster test_func_2() {
    Monster obj;
    return obj;
}

int main() {
    test_func_2();

    return 0;
}

test2怎么工作的？

  1. 从主调函数（main里面的test2）进入被调函数（Monster test_func_2()），这个过程没有参数不存在调用别的函数的可能性。

  2. 执行函数体。定义一个obj，obj是无参构造，定义这个obj就是调用了这个无参构造。然后返回，但是obj是个栈区的对象，是不会这么简单就返回的。栈区的对象会在函数体结束后自动被系统回收内存。也就是说回收完就没了。既然他都没了，那就不会被返回出去。那返回出去的是啥呢？其实是obj的复制体。既然要返回一个复制体，那就必然要拷贝一份出去了。拷贝构造的这一份，就在你函数调用的地方返回出去了。也就是test_func_2();返回出来

void test_func_1(Monster obj) {}

Monster test_func_2() {
    Monster obj;
    return obj;
}

int main() {
    test_func_2();//没人接收复制体就会释放掉

    Monster monster = test_func_2();//monster接收了复制体

    return 0;
}

在这里插入图片描述

如果没有东西去接收obj的复制体的话，会有一个看不见的透明的对象在test_func_2()；的外面接收obj返回的值。

void test_func_1(Monster obj) {}

Monster test_func_2() {
    return Monster();//创建匿名对象
}

int main() {
    test_func_2();//没人接收复制体就会释放掉

    return 0;
}

在这里插入图片描述

这里，可以认为在这个return 后面的Monster()是在函数外面了。所以在这里创建了Monster()就没有再去拷贝了。

浅拷贝：默认都是浅拷贝（无脑抄袭）

深拷贝：需要自己根据实际情况实现（有点脑子）

怎么防止默认拷贝发生？

防不胜防，想点办法。

声明一个私有的拷贝构造函数，但是不对它进行定义。即主动让程序报错。

流星白龙
关注
专栏目录
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数
08-29
在C++编程中，正确地管理类的构造函数、拷贝构造函数、析构函数和赋值函数是创建健壮、无内存泄漏程序的关键。接下来将详细介绍如何为自定义的String类编写这些函数，并通过实例来加深理解。 首先，我们定义一个...
C++中构造函数与析构函数的调用顺序详解
12-31
在一般情况下，调用析构函数的次序正好与调用构造函数的次序相反：最先被调用的构造函数，其对应的(同一对象中的)析构函数最后被调用，而最后被调用的构造函数，其对应的析构函数最先被调用。 简单来说，其构造函数...
【C++】构造函数与析构函数
明朗晨光的专栏
11-01 4739
C++构造函数和析构函数
c++的构造函数与析构函数
zzt_is_me的博客
09-08 1476
如果类中有单参的构造函数，那么它的参数类型数据就能隐藏提升为类对象，如果不使用该功能，可以在单参构造函数的前面加 explicit 关键字，参数类型数据就不能再隐藏提升为类对象。注意：在使用new[] 创建n个对象时，无法保证给所有的类对象都单独提供参数，去调用有参构造，那么必然需要调用无参构造，此时如果没有显式实现无参构造，编译就会出错。在创建类对象时，一定会调用构造函数，如果类中没有显式实现构造函数，编译器会自动生成一个无参的什么都不做的构造函数。cout << "我是无参构造函数" << endl;
C++基础：构造函数与析构函数
weixin_58368590的博客
05-26 2736
数据成员多为私有的，要对他们进行初始化，必须用一个公有函数来进行。同时这个函数应该在定义对象时自动执行一次。称为构造函数。 构造函数的用途：1）创建对象；2）初始化对象中的属性；3）类型转换 构造函数的定义与使用： 构造函数是特殊的公有成员函数（在特殊用途中构造函数的访问限定可以定义成私有或者保护）。其特征如下： 1.函数名与类型名相同。 2.构造函数无函数返回类型说明。注意是没有而不是void,即什么也不写，也不可以写成void。实际上构造函数有返回值，返回的就是构造函数所创建的对象...
C++中的构造函数与析构函数
scott198512的博客
12-02 2501
C++构造函数与析构函数
C++_构造函数与析构函数
安权_code的博客
12-15 1662
构造函数和析构函数都是属于类中的成员函数，在实例化一个对象时系统会自动调用该对象的构造函数，因此他常用于初始化对象成员变量，一个对象在其生命周期中只会调用一次构造函数。而析构函数与构造函数作用”相反“，他是在对象销毁时自动被系统调用的，所以他的任务是清理、释放对象申请的空间资源，一个类中只能有一个析构函数。
C++构造函数、析构函数以及拷贝构造函数
kirotsupreme的博客
04-22 1004
文章主要介绍了C++中六个默认成员函数中的三个：构造函数、析构函数以及拷贝构造函数，希望对读者有所帮助。
构造函数与析构函数
weixin_57248528的博客
10-04 8721
自定义的类里面是存在成员函数的；构造函数、析构函数、拷贝构造函数、赋值重载以及取地址重载等，而本节则主要论述前两个函数，构造函数和析构函数！关于类和对象这部分内容，是有些晦涩的，不易理解的，主要是其中要点过于琐碎，还是应该回归于书本！
C++构造函数与析构函数
weixin_64603510的博客
08-15 1150
C++构造函数与析构函数
C++:类的构造函数与析构函数
小青菜的博客
01-23 3357
构造函数与析构函数
【C++初阶】简析构造函数、析构函数
Captain_ldx的博客
10-04 2113
讲讲构造函数、析构函数的知识
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 251
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
ChoSeitaku的博客
11-04 643
表A，B都有序，可从第一个元素起依次比较A、B两表的元素，若元素值不等，则值小的值往后移，若元素值相等，则创建一个值等于两节点的元素值的新节点，使用尾插法插入到新的链表中，并将两个原表指针后移一位，直到其中一个链表遍历到表尾。一个工作指针cura用来遍历链表A，一个工作指针curb用来遍历链表B，一个工作指针curc用来建立链表C，一个指针new用来创建共同节点的新节点尾插到C链表上。循环结束后，如果curb指向NULL，表示链表B的curb都等于对应的cura，链表B是链表A的连续子序列。
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 589
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++之指针和引用
weixin_42300449的博客
11-04 131
在C++中，指针和引用是两种不同的机制，它们都可以用来间接访问变量。
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 192
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
c++之 stack(栈)和queue(队列)
2301_80028974的博客
11-04 612
文档stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
最新发布
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 150
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值