继承之动态内存分配&深拷贝浅拷贝

最新推荐文章于 2022-09-19 09:47:27 发布
最新推荐文章于 2022-09-19 09:47:27 发布
阅读量602 收藏
点赞数
分类专栏： c++ 文章标签： c++ c++类继承 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25235869/article/details/51020634
版权

baseDMA.h

#ifndef BASEDMA_H_
#define BASEDMA_H_
#include <iostream>

//基类
class baseDMA
{
private:
	char *label; //动态内存分配
public:
	baseDMA(const char *l = "null"); //构造函数
	baseDMA(const baseDMA & rs); //复制函数
	virtual ~baseDMA();
	baseDMA & operator = (const baseDMA & rs); //赋值函数
	friend std::ostream & operator<<(std::ostream & os,const baseDMA & ou_ob);
};


//派生类不使用动态内存分配
class lacksDMA:public baseDMA 
{
private:
	char color[100];
public:

	lacksDMA(const char *co = "null",const char *l = "null");
	friend std::ostream & operator<<(std::ostream & os,const lacksDMA & ou_ob);
};

//派生类使用动态内存分配
class hasDMA:public baseDMA 
{
private:
	char *style; //动态内存分配
public:
	hasDMA(const char *l = "null", const char *s = "null"); //构造函数
	hasDMA(const hasDMA & ha);//复制函数
	hasDMA & operator = (const hasDMA & ha);
	virtual ~hasDMA();
	friend std::ostream & operator<<(std::ostream & os,const hasDMA & ou_ob);
};

#endif

baseDMA.cpp 

#include "baseDMA.h"


//baseDMA
baseDMA::baseDMA(const char *l)
{
	label = new char[std::strlen(l)+1];
	std::strcpy(label,l);
}

baseDMA::baseDMA(const baseDMA & re) 
{

	this->label = new char[std::strlen(re.label)+1];
	std::strcpy(this->label,re.label);
}

baseDMA::~baseDMA()
{
	std::cout << "来自baseDMA析构函数" << "(地址:" << this <<")\n";
	delete [] this->label;
}

baseDMA & baseDMA::operator=(const baseDMA & rs)
{
	if(this == &rs) //如果是同样的一个相互复制 直接return
	{
		return *this;
	}
	delete [] this->label;
	this->label = new char [std::strlen(rs.label) + 1];
	std::strcpy(this->label,rs.label);
		return *this;
}
std::ostream & operator<<(std::ostream & os,const baseDMA & ou_ob)
{
	os<< "label--->" << ou_ob.label << std::endl;
	return os;
}


//lacksDMA
lacksDMA::lacksDMA(const char *co, const char *l):baseDMA(l)
{
	
	std::strcpy(this->color,co);
}

std::ostream &operator<<(std::ostream & os, const lacksDMA & ou_ob)
{

	os << (baseDMA)ou_ob; //强制装换调用基类的重载输出

	//std::cout << &(baseDMA)ou_ob << std::endl;
	//这里强制转换 编译器会弄出来一个baseDMA的临时变量 并且用baseDMA的析构函数去析构它

	os << "color--->" << ou_ob.color << std::endl;
	return os;
}


//hasDMA
hasDMA::hasDMA(const char *l, const char *s):baseDMA(l)
{
	this->style = new char [std::strlen(s) + 1];
	std::strcpy(this->style,s);
}


hasDMA::hasDMA(const hasDMA & ha):baseDMA(ha) //复制构造函数
{
	this->style = new char [std::strlen(ha.style) + 1];
	std::strcpy(this->style,ha.style);
}


hasDMA & hasDMA::operator = (const hasDMA & ha) //赋值函数 //可以直接使用 基类构造函数吗? 
{
	if(this == &ha)
	{
		return *this;
	}
	//使用基类的赋值构造函数
	baseDMA::operator=(ha);
	delete [] this->style;
	std::strcpy(this->style,ha.style);
	return *this;
}
hasDMA::~hasDMA() //需要显示的调用 基类的析构函数吗? (不需要 编译器会自动调用 手动在这里在调用一次的话会出问题)
{
	
	std::cout << "来自hasDMA析构函数" << "(地址:" << this <<")\n";
	delete [] this->style;
}


std::ostream & operator<<(std::ostream & os,const hasDMA & ou_ob)
{
	os << (baseDMA)ou_ob;
	os << "style--->" << ou_ob.style << std::endl;
	return os;
}
Main.cpp 

#include"baseDMA.h"

using std::cout;
void testBaseDestructor()
{
	baseDMA base("这个函数测试baseDMA析构函数生效情况");
	cout << base;
}

void testLacksDestructor()
{  
	lacksDMA lacks("这个函数测试lacksDMA析构函数生效情况","这个函数测试lacksDMA析构函数生效情况");
	cout << lacks;
}

void testhasDestructor()
{
	hasDMA has("这个函数测试hasDMA析构函数生效情况","这个函数测试hasDMA析构函数生效情况");
	cout << has;
}

void testSlightCopy(lacksDMA & f) //测试浅拷贝里面 A对象将值拷给B对象以后 A马上执行析构 B还存在吗? (存在)
{
	lacksDMA temp("hello","hi");
	f = temp; //浅拷贝
}
void main()
{
	cout << "/********测试baseDMA********/\n";
	baseDMA baseOne("hello baseDMA"); //使用构造函数
	cout << baseOne;
	baseDMA baseTwo(baseOne); //使用复制构造函数
	cout << baseTwo;
	baseDMA baseThree("hi baseDMA");
	cout << baseThree;
	baseThree = baseOne; //使用赋值函数
	cout << baseThree;
	testBaseDestructor();

	//输出结果:
	/*label--->hello baseDMA
	label--->hello baseDMA
	label--->hi baseDMA
	label--->hello baseDMA
	label--->这个函数测试baseDMA析构函数生效情况
	来自baseDMA析构函数(地址:0018F600)*/

	cout << "\n\n/********测试lacksDMA********/\n";
	lacksDMA lacksOne("hello lacksDMA' color","hello baseDMA' lable");//使用lacksDMA的构造函数(lacksDMA会调用baseDMA的构造函数)
	cout << lacksOne;
	cout << "\n";
	lacksDMA lacksTwo(lacksOne); //使用lacksDMA的复制构造函数
	cout << lacksTwo;
	cout << "\n";
	lacksDMA lacksThree("hi lacksDMA' color","hi baseDMA' lable");
	cout << lacksThree;
	lacksThree = lacksTwo; //使用lacksDMA的赋值构造函数
	cout << lacksThree;
	cout << "\n";
	testLacksDestructor();

	lacksDMA lacksFour("1","2");
	cout << lacksFour;
	testSlightCopy(lacksFour);
	cout << lacksFour;

	//输出结果:
	/* label--->hello baseDMA' lable
	来自baseDMA析构函数(地址:0018F538)
	color--->hello lacksDMA' color

	label--->hello baseDMA' lable
	来自baseDMA析构函数(地址:0018F538)
	color--->hello lacksDMA' color

	label--->hi baseDMA' lable
	来自baseDMA析构函数(地址:0018F538)
	color--->hi lacksDMA' color
	label--->hello baseDMA' lable
	来自baseDMA析构函数(地址:0018F538)
	color--->hello lacksDMA' color

	label--->这个函数测试lacksDMA析构函数生效情况
	来自baseDMA析构函数(地址:0018F3DC)
	color--->这个函数测试lacksDMA析构函数生效情况
	来自baseDMA析构函数(地址:0018F598) */

	cout << "\n\n/********测试hasDMA********/\n";
	hasDMA hasOne("hello baseDMA' lable","hello baseDMA' style");//使用hasDMA的构造函数
	cout << hasOne;
	cout << "\n";
	hasDMA hasTwo(hasOne); //使用hasDMA的复制构造函数
	cout << hasTwo;
	cout << "\n";
	hasDMA hasThree("hi baseDMA' lable","hi baseDMA' style");
	cout << hasThree;
	cout << "\n";
	hasThree = hasOne;  //使用hasDMA的赋值函数
	cout << hasThree;
	cout << "\n";
	testhasDestructor();
	//输出结果:
	/*label--->hello baseDMA' lable
	来自baseDMA析构函数(地址:0018F538)
	style--->hello baseDMA' style

	label--->hello baseDMA' lable
	来自baseDMA析构函数(地址:0018F538)
	style--->hello baseDMA' style

	label--->hi baseDMA' lable
	来自baseDMA析构函数(地址:0018F538)
	style--->hi baseDMA' style

	label--->hello baseDMA' lable
	来自baseDMA析构函数(地址:0018F538)
	style--->hello baseDMA' style

	label--->这个函数测试hasDMA析构函数生效情况
	来自baseDMA析构函数(地址:0018F440)
	style--->这个函数测试hasDMA析构函数生效情况
	来自hasDMA析构函数(地址:0018F5FC)
	来自baseDMA析构函数(地址:0018F5FC)*/
	system("pause");

}

/*总结:

1,派生类里面没有使用动态内存分配 那么复制构造函数,析构函数和赋值函数都不用重写(用编译器提供的默认潜拷贝就可以了)
	1),默认拷贝遇到char字符串会用strcpy进行复制.
2,派生类里面使用动态内存分配 那么派生来的复制构造函数,析构函数和赋值函数都要重写(如果不重写编译器使用浅拷贝拷贝原对象的地址 那么原对象被析构以后 拷贝它的对象就会出现问题)
3,在派生来的重载<<运算数输出里面,要显示调用基类的重载<<运算符
	1)且调用的时候要将派生类强制转换为基类,
		2)强制转换的时候编译器会弄出来一个临时对象
4,派生类里面使用动态内存分配的时候 析构函数要写为虚函数 派生类里面要重新实现析构函数 析构派生来里面动态分配的变量
	1)(在派生类里面的析构函数不用显示调用基类的析构函数,若调用 将出错)
5,
*/



qq_25235869
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态内存分配后的深拷贝与析构函数处理
weixin_44810857的博客
07-12 566
上一篇博文我们结尾讨论了拷贝构造函数中深拷贝与浅拷贝的区别以及深拷贝出现的原因，本节将学习类使用动态内存需考虑的拷贝构造函数和析构函数的处理。 回顾 当类中存在new初始化的指针（类对象在堆中申请了动态内存），默认构造函数只复制指针，不开辟新空间。导致两个指针指向同一块动态内存（浅拷贝），析构时会造成二次释放。 深拷贝：在堆区新开辟一块空间进行拷贝。 浅拷贝：简单的赋值拷贝操作，指向原来已经存在的内存；带来堆区内存重复释放的问题。 要点 1、只要类中带指针，就必须要有拷贝构造函数、析构函数、拷贝赋值函数
（一四二）继承和动态内存分配
weixin_34281477的博客
02-04 84
当基类、派生类用，或者不用动态内存时，共有四种情况： （注意，前提是基类的动态内存分配相关函数符合常规使用动态内存的要求） 情况一：基类使用动态内存分配、派生类新增数据成员不使用动态内存分配 假如基类使用动态内存分配（new），其必然设定①构造函数、②复制构造函数、③赋值运算符、④析构函数。 又知，派生类的构造函数（包括默认构造函数），需...
继承之浅拷贝与深拷贝
weixin_33858336的博客
04-17 584
前言 JS是面向对象的弱类型的语言，这对于js来说是一个非常大的特性之一。JS有属于自己的三大特性五大原则。 三大特性 封装 继承 多态 五大原则 单一职责原则 开发封闭原则 里氏替换原则 依赖倒置原则 接口隔离原则 在这里我主要概述下对 继承 的认识和简单的应用,其实继承主要的实现方式也是通过原型链的继承来继承父类的属性和方法的，也可以通过拷贝来复制一份属于自己的属性和方法 浅拷...
动态内存。复制n个hello world
qq_44912708的博客
10-26 105
char * GetStr(int n) {    int len=strlen("hello world ");  char *str=(char*)malloc((n*len+1)*sizeof(char));  str[0]='\0';  for(int i=0;i<n;i++)  {   strcat(s...
c++ --类中的动态内存管理、深拷贝
weixin_30537451的博客
07-02 143
知识点： 1. 深拷贝 　　类中含有指针成员时，需要显式定义构造函数实现深拷贝。 2. 类中的动态内存管理 　　保证类的析构函数被调用。 一切都在代码中： 1 #include <iostream> 2 #include <cstring> 3 #include <memory> 4 using namespace std; ...
类继承（动态内存分配）
11-09
- **深拷贝与浅拷贝**：当涉及对象复制时，要考虑到动态内存分配的对象。默认的拷贝构造函数和赋值运算符可能造成浅拷贝，导致意外的共享内存。需要自定义深拷贝来正确处理这种情况。 - **智能指针**：为了简化内存...
C++ 中继承与动态内存分配的详解
08-29
在编写这样的类时，遵循“资源获取即初始化”（RAII）原则和“深拷贝”、“浅拷贝”的概念，可以帮助确保正确管理内存。同时，了解并应用C++的构造函数、析构函数、复制构造函数和赋值操作符（也称为“五种特殊函数...
iOS中深拷贝与浅拷贝
01-20
可以看出深拷贝是直接拷贝对象到内存中的一块区域（分配了一块新的内存空间），然后把新对象的指针指向这块内存，原对象和被赋值对象互不影响。 深拷贝与浅拷贝的本质区别 在于是否在堆内存中开辟新的内存空间。 ...
A6:继承分配
03-26
当涉及对象的复制（如赋值或作为参数传递）时，需要考虑深拷贝和浅拷贝的概念。如果子类包含基类的指针或引用，不正确的拷贝可能会导致意外的结果。通常，需要提供自定义的拷贝构造函数和赋值运算符来确保正确处理...
习题5-多态、模板、const、拷贝构造(深拷贝)作业：.pdf
06-25
拷贝构造函数通常用于复制对象，如果需要复制对象的所有资源，包括动态分配的内存（深拷贝），就需要自定义拷贝构造函数。 5. **深拷贝（Deep Copy）**：深拷贝是指在复制对象时，不仅复制对象的成员变量，还复制...
类的动态内存分配 和复制构造函数
王铮Nio的博客
01-18 1621
class class_base { int* pt; public: class_base(int);//构造函数 class_base(const class_base&);//复制构造函数 virtual void show_info(); virtual ~class_base();//析构函数 };举例所用的类class_base如上面所示，具体的定义下面会给出。如果类的数据
c++ 复制之 类和动态内存分配（9）
SangoHan77的博客
01-23 502
本章介绍如何对类使用new和delete以及如何处理由于使用动态内存而引起的一些微妙的问题。 一个具体的例子——c++如何增加内存负载。假设要创建一个类，其一个成员表示某人的姓，最简单的方法是使用字符数组来保存姓，但初始化多大呢，40位？2000位？所有这时需要动态的在运行过程中创建合适长度的数组。通常的c++方法是，在类构造函数中使用new运算符在程序运行时分配所需的内存，还需要执行一些额外的
动态内存分配（转抄）
小熊之家
10-14 2301
1.堆内存分配 ：C/C++定义了4个内存区间：    代码区，全局变量与静态变量区，局部变量区即栈区，动态存储区，即堆（heap）区或自由存储区（free store）。堆的概念：通常定义变量（或对象），编译器在编译时都可以根据该变量（或对象）的类型知道所需内存空间的大小，从而系统在适当的时候为他们分配确定的存储空间。这种内存分配称为静态存储分配；    有些操作对象只在程序运行
类使用动态内存需注意的复制构造函数使用问题
个人工作中学到的专业技术与职业发展知识笔记
03-01 326
基础知识点介绍：复制构造函数 1、复制构造函数用于将一个对象复制到新创建的对象中。复制构造函数原型： Class_name(const Class_name& ); // 接受一个类对象的常量引用。 2、何时调用复制构造函数： 新建一个对象并初始化为现有对象时调用，例如： ClassA b(a); ClassA c = a; ClassA d = ClassA(a); ClassA * ...
python 对象内存分析
rockkyle的博客
11-02 355
python对象内存分析 一、python内建对象 python内建对象占用内存的情况又分为定长对象与非定长对象（变长） 1.1 定长对象,对象在内存中所占大小不会变化的对象 包括int，float，long，bool，complex和dict 测试程序如下： #!/usr/bin/env python #-*- coding:utf-8 -*- import sys pri...
python类的继承
小刘同学_iOS的专栏
08-18 880
Python 类的一些基本概念      Python中一切皆对象，声明变量函数等的过程实际上就是它们到内存中为对象分配的空间的连接。Python中的类同Java、C++一样，有自己的属性与方法。属于一个对象或类的变量被称为域。 域有两种类型——属于每个实例/类的对象或属于类本身，它们分别被称为实例变量和类变量。 类的变量 由一个类的所有对象（实例）共享使用。所有对象共用一个类变量的拷贝。对
继承和动态内存分配
最新发布
qq_55621259的博客
09-19 368
我们来看看拷贝构造函数，父类的拷贝构造函数没什么好说的，主要是子类，子类先用初始化列表将要传进来进行拷贝的子类对象传给父类，这是因为首先父类引用可以指向子类所以可以传，又因为我们对子类进行拷贝，子类中还有一些继承父类的组件得传给父类才能使得全部拷贝进去吧，否则只拷贝了子类自己特有的部分，因为我们必须传！最后我们看看重载赋值运算符，其实很容易想到重载赋值运算符其实和拷贝构造函数的功能是差不多的，因此基类的重载赋值运算符和拷贝构造函数的实现差不多。这里和上面子类的拷贝构造函数一样，也要先将父类拷贝了。
C++类的静态成员、动态内存分配和复制构造函数
sinat_18187903的博客
04-03 803
对于C++类使用静态成员对象有进一步的认识。通过了解复制构造函数，将会使设计的类更加完善。对使用new和delete会更清晰，避免程序设计过程中出现异常。
new与malloc之间的区别
sinat_29844779的博客
03-14 1559
1、new操作符从自由存储区上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是c++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，c语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。 自由存储区是否可以是堆？这取决于operate
C++中的深拷贝与浅拷贝原理解析
深拷贝（Deep Copy）则是在复制对象时，不仅复制对象的引用或指针，还会为底层数据分配新的内存并复制数据，确保原对象和副本各自拥有独立的内存空间。Str类的拷贝构造函数就是实现了深拷贝，它为传入对象的pstr分配...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值