C++之构造与析构（下）

最新推荐文章于 2023-02-04 17:26:22 发布
最新推荐文章于 2023-02-04 17:26:22 发布
阅读量200 收藏
点赞数 2
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QQ1402369668/article/details/104412589
版权

文章目录

C++中的对象组合

C++中的类可以使用其它类定义成员变量

问题：如何给对象成员进行初始化？

对象组合示例

#include <stdio.h>

class M
{
private:
    int mI;
public:
    M(int i)
    {
        printf("M(int i), i = %d\n", i);
        mI = i;
    }
    
    int getI()
    {
        return mI;
    }
};

class Test
{
private:
    const int c;
    M m1;
    M m2;
public:
    Test() 
    {
        printf("Test()\n");
    }    
};

int main()
{
    Test t1;
    
    printf("Press any key to continue...");
    getchar();
    
    return 0;
}

在这里插入图片描述

分析：编译错误，那么如何给对象成员进行初始化？

C++中提供了初始化列表对成员变量进行初始化

语法规则
Constructor::Contructor() : m1(v1), m2(v1,v2), m3(v3)
{
// some other assignment operation
}

#include <stdio.h>

class M
{
private:
    int mI;
public:
    M(int i)
    {
        printf("M(int i), i = %d\n", i);
        mI = i;
    }
    
    int getI()
    {
        return mI;
    }
};

class Test
{
private:
    const int c;
    M m1;
    M m2;
public:
    Test() : c(1), m2(3), m1(2) //成员变量的初始化顺序与声明的顺序相关，与在初始化列表中的顺序无关.   所以仍然是m1的构造函数先调用
    {
        printf("Test()\n");
    }
    
    void print()
    {
        printf("c = %d, m1.mI = %d, m2.mI = %d\n", c, m1.getI(), m2.getI());
    }
};

void run()
{
    Test t1;
    
    t1.print();
}

int main()
{
    run();
    
    printf("Press any key to continue...");
    getchar();
    
    return 0;
}

在这里插入图片描述

注意：
1.成员变量的初始化顺序与声明的顺序相关，与在初始化列表中的顺序无关
2.初始化列表先于构造函数的函数体执行

小插曲 类中的const成员

类中的const成员是肯定会被分配空间的
类中的const成员变量只是一个只读变量

注意：

编译器无法直接得到const成员变量的初始值，因此无法进入符号表成为真正意义上的常量。

注意：如果在const定义处可以看到它的值，则为真正意义上的常量，进入符号表；

​ 否则为只读变量；

#include <stdio.h>

class M
{
private:
    int mI;
public:
    M(int i)
    {
        printf("M(int i), i = %d\n", i);
        mI = i;
    }
    
    int getI()
    {
        return mI;
    }
};

class Test
{
private:
    const int c;
    M m1;
    M m2;
public:
    Test() : c(1), m2(3), m1(2) 
    {
    	//尝试用指针去修改c的值,结果修改成功
    	const int* pp = &c;
    	int* ppp = const_cast<int*>(pp);    	
    	*ppp = 111;
    	
        printf("Test()\n");
    }
    
    void print()
    {
        printf("c = %d, m1.mI = %d, m2.mI = %d\n", c, m1.getI(), m2.getI());
    }
};

void run()
{
    Test t1;
    
    t1.print();
}

int main()
{
    run();
    
    printf("Press any key to continue...");
    getchar();
    
    return 0;
}

在这里插入图片描述

分析：类中的const int c; 为只读变量；

初始化与赋值不同

初始化是用已存在的对象或值对正在创建的对象进行初值设置
赋值是用已存在的对象或值对已经存在的对象进行值设置

区别：
初始化：被初始化的对象正在创建
赋值：被赋值的对象已经存在

Test() : c(1) //此处c为初始化
{

​ c = 2; //此处c为赋值

}

对象的销毁

生活中存在的对象都是被初始化后才上市的
生活中的对象被销毁前会做一些清理工作

问题：如何清理被销毁的对象？

一般的解决方案

一般而言所有被销毁的对象都需要做清理

解决方案
为每个类都提供一个public的destroy函数
对象不再被需要时立即调用destroy函数进行清理

例如我们上一个例子中的destory()函数：

a1.destory();
a2.destory();

destroy只是一个普通的函数，必须显示的调用
如果对象销毁前没有做清理，那么很可能造成资源泄漏

​ 在构造函数中申请的资源，需要在对象销毁前释放

思考：C++编译器是否能够自动调用某个特殊的函数进行对象的清理？

C++中的析构函数

C++中的类可以定义一个特殊的成员函数清理对象
这个特殊的成员函数叫做析构函数
定义：~ClassName()
析构函数没有参数也没有任何返回类型的声明
析构函数在对象销毁时自动被调用

#include <stdio.h>

class Test
{
private:
    int mI;
public:
    Test(int i) : mI(i)
    {
        printf("Test(), mI = %d\n", mI);
    }
    
    ~Test()
    {
        printf("~Test(), mI = %d\n", mI);
    }
};

void run()
{
    Test t1(1);
    Test t2(2);
    Test t3(3);
    Test t4(4);
    Test t5(5);
}

int main()
{
    run();
    
    printf("Press any key to continue...");
    getchar();
    
    return 0;
}

在这里插入图片描述

Array类的进化

注意：析构函数不能重载

Array.cpp


#include "Array.h"

Array::Array(int length)
{
    if( length < 0 )
    {
        length = 0;
    }
    
    mLength = length;
    mSpace = new int[mLength];
}

Array::Array(const Array& obj)
{
    mLength = obj.mLength;
    
    mSpace = new int[mLength];
    
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
}

int Array::length()
{
    return mLength;
}

void Array::setData(int index, int value)
{
    mSpace[index] = value;
}

int Array::getData(int index)
{
    return mSpace[index];
}

Array::~Array() //析构函数
{
    printf("Array::~Array() \n");
    
    mLength = -1;
    delete[] mSpace;
}

Array.h


#ifndef _ARRAY_H_
#define _ARRAY_H_

class Array
{
private:
    int mLength;
    int* mSpace;

public:
    Array(int length);
    Array(const Array& obj);
    int length();
    void setData(int index, int value);
    int getData(int index);
    ~Array(); //析构函数
};

#endif

main.cpp

#include <stdio.h>
#include "Array.h"

int main()
{
    Array a1(10);
    
    for(int i=0; i<a1.length(); i++)
    {
        a1.setData(i, i);
    }
    
    for(int i=0; i<a1.length(); i++)
    {
        printf("Element %d: %d\n", i, a1.getData(i));
    }
    
    Array a2 = a1;
    
    for(int i=0; i<a2.length(); i++)
    {
        printf("Element %d: %d\n", i, a2.getData(i));
    }
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}

在这里插入图片描述

构造函数与析构函数的调用秩序

当类中有成员变量是其它类的对象时

​ 首先调用成员变量的构造函数
​ 调用顺序与声明顺序相同
​ 之后调用自身类的构造函数
析构函数的调用秩序与对应的构造函数调用秩序相反

析构函数的调用秩序与对应的构造函数调用秩序相反

#include <stdio.h>

class Test
{
private:
    int mI;
public:
    Test()
    {
        printf("Test()\n");
        mI = -1;
    }
    
    Test(int i)
    {
        printf("Test(int i), i = %d\n", i);
        mI = i;
    }
    
    Test(const Test& obj)
    {
        printf("Test(const Test& obj), i = %d\n", obj.mI);
        mI = obj.mI;
    }
    
    ~Test()
    {
        printf("~Test(), i = %d\n", mI);
    }
};

void func(Test t)
{
    Test r(1);
}

void run()
{
    Test t(0);
    
    func(t);
}

int main()
{
    run();
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}

在这里插入图片描述

小结：

析构函数是C++中对象销毁时做清理工作的特殊函数
析构函数在对象销毁时自动被调用
析构函数是对象所使用的资源及时释放的保障
析构函数的调用秩序与构造函数相反

类的内部可以直接调用类的构造函数吗？

如果可以，直接调用构造函数会有什么情况发生呢？

可以直接调用构造函数，直接调用构造函数将得到一个临时对象。

#include <stdio.h>

class Test
{
private:
    int mI;
    int mJ;
    const char* mS;
public:
    Test()
    {
        printf("Test()\n");
        
        mI = 0;
        mJ = 0;
    }
    
    Test(const char* s)
    {
        printf("Test(const char* s)\n");
        
        Test();
        
        mS = s;
    }
    
    ~Test()
    {
        printf("~Test()\n");
    }
    
    void print()
    {
        printf("mI = %d, mJ = %d, mS = %s\n", mI, mJ, mS);
    }
};

void run()
{
    Test t = Test("Delphi Tang"); // Test t("Delphi Tang");
    
    t.print();
}

int main()
{
    run();
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}

在这里插入图片描述

分析：mI和mJ并没有赋值为0；

tsfg
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++构造函数和析构函数的使用与讲解
01-20
函数名与类名必须相同。 b.没有返回值 例如： class Obj { ... public: Obj() { ... } }; 2.构造函数可以带参数，也可以重载 class Obj { ... public: Obj() { ... } Obj(int x, int y) { ... } }; 3...
C++ 构造与析构
04-29
此ppt介绍了C++种构造函数与析构函数的原理及用法，深入浅出，适合入门级C++学习者。结合C++变成原理可以更好的理解并运用、
C++ 构造和析构
weixin_33862041的博客
01-12 323
1、继承关系可认为，子类在父类的基础上进行。从这个角度讲，可把它认为穿衣脱衣的过程。穿衣是：先穿内衣，再穿外套。脱衣是：先脱外套，在脱内衣。构造是：先调用父类构造方法，再调用子类构造方法。析构是：先调用子类析构方法，再调用父类析构方法。 2、构造可分为两个步骤：初始化列表和方法内赋值。前者的使用场景是：初始化，即copy构造。后者的使用场景是：赋值，即copy赋值。 　　a、对于类类型，如果没...
C++构造和析构
重剑无锋
09-04 1257
#include  using namespace std;class B {  public:     B()     {        cout"default constructor"    }     B( B &b)    {        cout"copy constructor"    }    ~B()     {
c++：构造与析构
qq_45009980的博客
07-30 90
/*c++中还提供了一些封装方法：构造方法、析构方法 一、在声明一个类的对象后，要对该对象进行初始化，即对对象中的数据成员赋值 构造函数：用于创建一个对象，提供初始化该对象的简单手段 函数语法：（构造函数的函数名必须与类名相同；它没有返回值；作用为初始化对象；其调用是在声明对象时候自动调用（python中的__init__）） <类名> (<参数表>){ ...
【C++】构造与析构
BebopPrimer的博客
02-04 735
【C++】构造与析构
C++构造函数和析构函数顺序
12-22
构造函数 　先看看构造函数的调用顺序规则，只要我们在平时编程... 　析构函数的调用顺序与构造函数的调用顺序正好相反，将上面3个点反过来用可以了，首先调用派生类的析构函数；其次再调用成员类对象的析构函数；后调
C++ 的构造/析构/赋值/拷贝函数比较
08-19
构造函数、析构函数与赋值函数是每个类最基本的函数。每个类只有一个析构函数，但可以有多个构造函数（包含一个拷贝构造函数，其它的称为普通构造函数）和多个赋值函数（除了同类的赋值以外，还有其他的赋值方法）。
C++之构造与析构（上）
创造晴天
02-20 139
文章目录对象的初始化解决方案忘记调用initialize（）函数的后果C++中的构造函数构造函数的调用成员函数的重载：两个特殊的构造函数拷贝构造函数的行为方式实例代码：数组类的创建解决方案：自己写拷贝构造函数 对象的初始化 生活中存在的对象都是被初始化后才上市的 初始状态是对象普遍存在的一个状态的 问题：如何给对象进行初始化？ 一般而言所有的对象都需要一个确定的初始状态 解决方案 为每个类都提供一...
C++中的构造函数和析构函数
cqxcool66的博客
05-13 594
构造函数 定义：每个类都分别定义了它的对象呗初始化的方式，类通过一个或者几个特殊的成员函数来控制其对象的初始化过程，这些函数叫做构造函数。 在对象建立的时候，就会执行构造函数。 特点： 构造函数的名字和类名相同。 构造函数没有返回值。 构造函数也有一个参数列表（可能为空）和一个函数体（可能为空）。 类可以有多个构造函数，和其它重载函数类似，不同的构造函数之间必须在参数数量或者类型上有区别。 如果类没有显示的定义构造函数，编译器会自动隐式的定义一个默认构造函数。 构造函数方式： 默认构造函数。
C++中构造和析构介绍
天下
10-28 166
C++中构造和析构介绍： 1.C++中的类可以定义与类名相同的特殊的成员函数， 2.与类名相同的成员函数叫做构造函数 3.构造函数在定义时可以有参数，但是没有任何返回类型的声明 4.类中的成员函数可以和普通函数一样进行重载，遵守相同的重载规则。 两个特殊的构造函数：分别是无参构造函数和拷贝构造函数 1.当类中没有定义任何一个构造函数，c++编译器会提供无参构造函数和拷贝构造函数 2....
进一步理解C++构造与析构
Jerish的博客
01-19 1577
在之前的浅析C++智能指针一文中，我们提到过，在C语言中我们用malloc和free来申请和释放内存。而在C++语言中，我们常用new与delete来申请和释放内存。 我们要知道，new，delete与malloc，free是有区别的，new一个对象时，我们不仅申请了内存同时构造了对象，delete一个对象时，我们不仅释放了内存还销毁了对象。   那么我们在C++中想分开操作或只想申请内存怎
【③C++ | 构造与析构函数】特性介绍 | 调用机制 | 用途展示 | 深浅拷贝 | 拷贝构造中的骚操作
热爱编程的小K的博客
01-01 707
构造函数和析构函数对于类的使用和对象的生命周期非常重要。构造函数负责初始化对象的状态，确保对象在创建后处于可使用的有效状态。析构函数则负责清理对象所占用的资源，防止内存泄漏和资源泄漏。
C++中 destory() 和deallocate()以及delete函数的相关性和区别性
weixin_30333885的博客
08-23 465
　　 这里非常的绕口 需要仔细的来看看： 　destory(): 显示调用一个对象的析构函数 相当于释放一个对象需要释放的一些动态内存 为下次真正释放对象做准备 　deallocate():真正的释放一个内存块。这是一个上层封装也就是delete函数的上层封装 在STL的空间配置器中 有可能会调用delete还给OS 也有可能就是放在内存池中 但是对于用户来讲就是释放内存块。 ...
C++ 之 for 循环 | C++11 for 循环 | 内存 Destory 示例
专注于AI领域前沿技术学习与分享：目标检测、图像修复、超分重建、AI工程化
04-06 309
这C++ 之 传统 for 循环 和 C++11 for 循环 #include <iostream> int main() { int arr[4] = {100, 200, 300, 400}; std::cout << "传统 for 循环如下" << std::endl; std::cout << "___________________" << std::endl; for (int i = 0.
c++构造函数和析构函数
最新发布
06-07
C++中的构造函数和析构函数是用来初始化和清理类对象的特殊成员函数。构造函数在对象被创建时自动调用，而析构函数则在对象被销毁时自动调用。 构造函数的名称与类名称相同，没有返回类型，可以有参数，分为默认...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值