【C++---14】类与对象(中):对象数组,对象成员,深拷贝和浅拷贝'

最新推荐文章于 2022-05-03 21:42:18 发布
最新推荐文章于 2022-05-03 21:42:18 发布
阅读量785 收藏 3
点赞数 1
分类专栏： C++初期代码录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44749767/article/details/96873361
版权

目录

对象数组:

对象成员:

小题题:

深拷贝和浅拷贝:

浅拷贝实践:

深拷贝实践:

比较:

对象数组:

class Coordinate
{
public:
	int m_iX;
	int m_iY;
};

int main(void)
{
	Coordinate coord[3];//栈上实例化数组
	coord[1].m_iX = 10;//访问数据成员
	Coordinate *p = new Coordinate[3];//堆上实例化数组
	p[0].m_iY = 20;//
	p->m_iY = 20;//指针访问赋值
	delete[]p;
	p = NULL;
	return 0;
}

 

代码演示:


/*
对象数组:
要求:
     1.定义Coordinate类
	 2.数据成员:m_iX和m_iY
	 3.分别从栈和堆中实例化长度为3的对象数组
	 4.给数组元素分别赋值
	 5.遍历两个数组
*/
class Coordinate
{
public:
	Coordinate();
	~Coordinate();
public:
	int m_iX;
	int m_iY;
};

Coordinate::Coordinate()
{
	cout << "Coordinate" << endl;

}
Coordinate::~Coordinate()
{
	cout << "~Coordinate" << endl;

}


int main(void)
{
	Coordinate coor[3];//栈上实例化数组
	coor[0].m_iX = 1;
	coor[0].m_iY = 3;//访问数据成员
	Coordinate *p = new Coordinate[3];//堆上实例化数组
	p[0].m_iX= 2;//
	p->m_iY = 4;//指针访问赋值,第一个元素

	p++;
	p[0].m_iX = 6;//第二个元素
	p->m_iY = 8;

	p[1].m_iX = 10;//第三个元素赋值
	p++;
	p->m_iY = 12;


	for (int i = 0; i < 3; i++)
	{
		cout << "coor_x"<<coor[i].m_iX << endl;
		cout << "coor_y"<<coor[i].m_iY << endl;
	}
	/*
	//假设没有进行过p++
	for (int j = 0; j < 3; j++)
	{
		cout <<"p_x"<< p[j].m_iX << endl;
		cout << "p_y"<<p[j].m_iY << endl;
	}
	*/
	//事实上:
	for (int j = 0; j < 3; j++)
	{
		cout << "p_x" << p->m_iX << endl;
		cout << "p_y" << p->m_iY << endl;
		p--;
	}
	p++;//
	delete[]p;
	p = NULL;
	return 0;
}

实例化对象数组时，每一个对象的构造函数都会被执行。

实例化对象数组时，内存既可以从堆上分配，也可以从栈上分配。

销毁对象数组时，每一个对象的析构函数都会被执行。

堆中实例化的数组需要手动销毁释放内存，在栈中实例化的数组，系统自动回收内存.

对象成员:

对象成员：对象中还可能包含着其他对象

代码演示:

demo.cpp

#include<iostream>
#include<stdlib.h>
#include<string>
#include"Line.h"
using namespace std;
/*对象成员
要求：
     定义两个类：
	坐标类:Coordinate
	数据成员：m_iX和m_iY
	成员函数：构造函数，析构函数，数据封装函数
	线段类：Line
	数据成员：点A m_coorA，点B m_coorB
	成员函数：构造函数，析构函数，数据封装函数，信息打印函数*/

int main(void)
{
	Line *p = new Line();
	delete p;
	p = NULL;

	system("pause");
	return 0;
}
Line.cpp

#include"Line.h"
#include<iostream>
using namespace std;

Line::Line()
{
	cout << "Line" << endl;
}
Line::~Line()
{
	cout << "~Line" << endl;
}
void Line::setA(int x, int y)
{
	m_coorA.setX(x);
	m_coorA.setY(y);
}
void Line::setB(int x, int y)
{
	m_coorB.setX(x);
	m_coorB.setY(y);
}

void Line::printInfo()
{
	cout << "(" << m_coorA.getX() << m_coorA.getY() << ")" << endl;
	cout << "(" << m_coorB.getX() << m_coorB.getY() << ")" << endl;
}

Line.h
#include"Coordinate.h"

class Line
{
public:
	Line();
	~Line();
	void setA(int x,int y);
	void setB(int x,int y);
	void printInfo();
private:
	Coordinate m_coorA;
	Coordinate m_coorB;
};
Coordinate.cpp

#include"Coordinate.h"
#include<iostream>
using namespace std;

Coordinate::Coordinate()
{
	cout << "Coordinate()" << endl;
}
Coordinate::~Coordinate()
{
	cout << "~Coordinate()" << endl;
}
void Coordinate::setX(int x)
{
	m_iX = x;
}
int Coordinate::getX()
{
	return m_iX;
}
void Coordinate::setY(int y)
{
	m_iY = y;
}
int Coordinate::getY()
{
	return m_iY;
}
Coordinate.h

class Coordinate
{
public:
	Coordinate();
	~Coordinate();
	void setX(int x);
	int getX();
	void setY(int y);
	int getY();
private:
	int m_iX;
	int m_iY;
};

实例化对象A时，如果对象A有对象成员B，那么先执行对象B的构造函数，再执行A的构造函数。

如果对象A中有对象成员B，那么销毁对象A时，先执行对象A的析构函数，再执行B的析构函数。

如果对象A中有对象成员B，对象B没有默认构造函数，那么对象A必须在初始化列表中初始化对象B。

小题题:

定义具有2个对象的Coordinate数组，遍历对象数组，打印对象信息

结果如图所示

#include <iostream>
using namespace std;
class Coordinate
{
    
public:
	Coordinate()
	{
	}
	// 打印坐标的函数
	void printInfo()  
	{
	   cout<<"("<<m_iX<<","<<m_iY<<")"<<endl; 
	}
public:
	int m_iX;
	int m_iY;
};
int main(void)
{
	//定义对象数组
    Coordinate coorArr[2] ;
    coorArr[0].m_iX=1;
    coorArr[0].m_iY=2;
    coorArr[1].m_iX=3;
    coorArr[1].m_iY=4;
    




	//遍历数组，打印对象信息
	for(int i = 0; i < 2; i++)
	{
		coorArr[i].printInfo();
	}	
	return 0;
}

深拷贝和浅拷贝:

浅拷贝：拷贝后指针指向相同的内存。

深拷贝：申请新的内存，逐位存放内容;

浅拷贝后:对象销毁存在问题,同一块内存释放两次;

 

为了达到两个对象指针指向不同内存,拷贝时是将内存中的数据拷贝过来;

深拷贝代码如下:

在对含有指针成员的对象进行拷贝时，必须要自己定义拷贝构造函数，使拷贝后的对象指针成员有自己的内存空间，并用for循环将每一个成员都拷贝即进行深拷贝，这样就避免了内存泄漏发生。

 

 

浅拷贝实践:

 

  1. 定义一个Array类;
  2. 数据成员包括数据封装函数,构造函数,拷贝构造函数,和析造函数;
  3. 通过此示例体会浅拷贝原理
  • Array.h
class Array
{
public:
	Array();//构造函数
	Array(const Array&arr);//拷贝构造函数
	~Array();//析构函数
		void setCount(int count);
	int getCount();

	private:
		int m_iCount;
};
  • Array.cpp
  • /*
1.定义一个Array类,
      数据成员包括数据封装函数,构造函数,拷贝构造函数,和析造函数
	  2.通过此示例体会浅拷贝原理
	  3.增加数据成员m_pArr,增加m_pArr地址查看函数,
	  同时改造构造函数,拷贝构造函数和析造函数,体会深拷贝的原理和必要性

*/

#include"Array.h"
#include<iostream>
using namespace std;

Array::Array()//构造函数
{
	cout << "Array" << endl;
}
Array::Array(const Array& arr)//拷贝函数
{
	m_iCount = arr.m_iCount;//拷贝
	cout << "Array&" << endl;//加上&与前面的Array相区别
}
Array::~Array()//析构函数
{
	cout << "~Array" << endl;
}
void Array::setCount(int count)//数据的封装
{
	m_iCount = count;
}
int Array::getCount()
{
	return m_iCount;
}
int main(void)
{
	Array arr1;//实例化对象
	arr1.setCount(10);

	Array arr2(arr1);//说明浅拷贝,
	cout << "arr2.m_iCount  " << arr2.getCount() << endl;

	system("pause");
	return 0;
}

    Arr1和Arr2都指向同一内存，但是析构函数中的delete []m_pArr只有一个，所以会释放同一地址的内存两遍，此时程序就会卡在析构函数。

    浅拷贝直接赋值

深拷贝实践:

  1. 增加数据成员m_pArr,增加m_pArr地址查看函数,
  2. 同时改造构造函数,拷贝构造函数和析造函数,体会深拷贝的原理和必要;

Array.h

class Array
{
public:
	Array(int count);//构造函数
	Array(const Array&arr);//拷贝构造函数
	~Array();//析构函数
	void setCount(int count);
	 int getCount();
	 void printAddr();
	 void printArr();
	private:
		int m_iCount;
		int *m_pArr;
};

Array.cpp

/*
1.定义一个Array类,
      数据成员包括数据封装函数,构造函数,拷贝构造函数,和析造函数
	  2.通过此示例体会浅拷贝原理
	  3.增加数据成员m_pArr,增加m_pArr地址查看函数,
	  同时改造构造函数,拷贝构造函数和析造函数,体会深拷贝的原理和必要性

*/

#include"Array.h"
#include<iostream>
using namespace std;

Array::Array(int count)//构造函数
{
	m_iCount = count;
	m_pArr = new int[m_iCount];
	for (int i = 0; i < m_iCount; i++)
	{
		m_pArr[i] = i;
	}
	cout << "Array" << endl;
}
Array::Array(const Array& arr)//拷贝函数
{
	//m_pArr = arr.m_pArr;//浅拷贝,直接赋值

	m_iCount = arr.m_iCount;//拷贝.先复制
	m_pArr = new int[m_iCount];//分配内存
	
	for (int i = 0; i < m_iCount; i++)
	{
		m_pArr[i]= arr.m_pArr[i];//逐个拷贝,深拷贝
	}
	
	cout << "Array&" << endl;//加上&与前面的Array相区别
}
Array::~Array()//析构函数
{
	delete[]m_pArr;
	m_pArr = NULL;
	cout << "~Array" << endl;
}
void Array::setCount(int count)//数据的封装
{
	m_iCount = count;
}
int Array::getCount()
{
	return m_iCount;
}


void Array::printAddr()
{
	cout << "m_pArr的值:" << m_pArr << endl;
}
void Array::printArr()
{
	for (int i = 0; i < m_iCount; i++)
	{
		cout << m_pArr[i] << endl;
	}

}

int main(void)
{
	Array arr1(5);//实例化对象

	Array arr2(arr1);//说明浅拷贝,
	arr1.printArr();
	arr2.printArr();
	

	system("pause");
	return 0;
}

m_iCount = arr.m_iCount;

m_pArr = new int[m_iCount];

上面两个顺序不能换。

 

比较:

【浅拷贝】是增加了一个指针，指向原来已经存在的内存。而【深拷贝】是增加了一个指针，并新开辟了一块空间，让指针指向这块新开辟的空间。

【浅拷贝】在多个对象指向一块空间的时候，释放一个空间会导致其他对象所使用的空间也被释放了，再次释放便会出现错误;

小点点:

  1. 拷贝对象时，不会执行构造函数，而是执行拷贝构造函数;
  2. 关于 深拷贝与浅拷贝需要知道的基本概念和知识：
  3. （1）什么时候用到拷贝函数？  
  4. a.一个对象以值传递的方式传入函数体；  
  5. b.一个对象以值传递的方式从函数返回；  
  6. c.一个对象需要通过另外一个对象进行初始化。
  7. 如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。
  8. 位拷贝又称浅拷贝 如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝
  9. 深拷贝时，需要在拷贝构造函数中，重新分配堆内存，并将堆内存地址上的值复制给新的堆内存;
  10.  
霜前月下
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 类的深拷贝
05-22
设计并实现一个动态整型数组类Vect，要求： （1）实现构造函数重载，可以根据指定的元素个数动态创建初始值为0的整型数组，或根据指定的内置整型数组动态创建整型数组。 （2）设计拷贝构造函数和析构函数，注意使用深拷贝。 （3）设计存取指定位置的数组元素的公有成员函数，并进行下标越界，若越界则输出“out of boundary”。 （4）设计获取数组元素个数的公有成员函数。 （5）设计用于输出数组元素的公有成员函数，元素之间以空格分隔，最后以换行符结束。 在main函数中按以下顺序操作： （1）根据内置的静态整型数组{1,2,3,4,5}构造数组对象v1，根据输入的整型数构造数组对象v2。 （2）调用Vect的成员函数依次输出v1和v2的所有元素。 （3）输入指定的下标及对应的整型数，设置数组对象v1的指定元素。 （4）根据数组对象v1拷贝构造数组对象v3。 （5）调用Vect的成员函数依次输出v1和v3的所有元素。 设计并实现一个动态整型数组类Vect，要求： （1）实现构造函数重载，可以根据指定的元素个数动态创建初始值为0的整型数组，或根据指定的内置整型数组动态创建整型数组。 （2）设计拷贝构造函数和析构函数，注意使用深拷贝。 （3）设计存取指定位置的数组元素的公有成员函数，并进行下标越界，若越界则输出“out of boundary”。 （4）设计获取数组元素个数的公有成员函数。 （5）设计用于输出数组元素的公有成员函数，元素之间以空格分隔，最后以换行符结束。 在main函数中按以下顺序操作： （1）根据内置的静态整型数组{1,2,3,4,5}构造数组对象v1，根据输入的整型数构造数组对象v2。 （2）调用Vect的成员函数依次输出v1和v2的所有元素。 （3）输入指定的下标及对应的整型数，设置数组对象v1的指定元素。 （4）根据数组对象v1拷贝构造数组对象v3。 （5）调用Vect的成员函数依次输出v1和v3的所有元素。
C++ 深拷贝
꧁༺ʚvv༒catɞ༻꧂的博客
11-29 1442
#include <iostream> #include <cstdlib> using namespace std; int strlen(const char s[]){ int len = 0; while (s[len]){ len++; } return len; // 返回数组str中首个值为null的元素的下标值 } char* strcpy(char *p, const char *s){ char *t = p; while (*p+
C++——深拷贝
dashen2259的博客
01-08 393
要实现深拷贝就需要自己编写拷贝构造函数。 深拷贝 #include<iostream> using namespace std; class Point { public: Point() {X=Y=0;cout<<"Default Constructor called."<<endl;...
C++安全方便高效地复制对象数组
01-21
在C++中，我们经常遇到需要对一个对象数组进行复制，比如下面一个结构： struct STest {     int a;     int b;     vector<int> vctInt; }; 　　我们定义了两个数组： STest A[20]; STest B[20]; 　　需要将数组A中的所有内容复制到B数组中，通常我们的做法都是这样： for(size_t i = 0; i < ARRAYSIZE(A); ++i) {     A[i] = B[i]; } 　　这里不能直接使用memcpy，因为STest中有vector类型。但是，如果我们定
【C++之浅拷贝和深拷贝】举例对象内数组的拷贝
Brianone的博客
05-03 3143
待定
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
详解C++中String类模拟实现以及深拷贝浅拷贝 在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们...
C++拷贝构造函数(深拷贝与浅拷贝)详解
09-05
深拷贝和浅拷贝是C++中处理对象复制时的两个关键概念，尤其在涉及到动态内存分配的情况。浅拷贝，也称为位拷贝，是指仅仅复制对象的成员变量的值，而不复制底层的资源。这意味着如果类的成员变量包含指针，那么新...
实现数组复制常用的5种方式及组合类的深复制(深拷贝)
12-21
在Java编程中，数组复制是常见的操作，有多种方法可以实现这一目标，包括浅复制和深复制。浅复制仅复制对象引用，而深复制则复制整个对象及其引用的对象。这里我们将详细讨论五种常见的数组复制方法，并探讨如何通过...
对浅拷贝、深拷贝、写时拷贝的简单认识
01-20
在自定义的`string`类中，深拷贝会创建一个新的字符数组并复制原始字符串的内容，确保每个对象都有自己的内存区域。 例如，上述代码展示了如何实现深拷贝。拷贝构造函数和赋值运算符通过创建临时对象来实现深拷贝，...
C++对象的浅复制和深复制详解及简单实例
08-30
总结起来，理解C++中的浅复制和深复制是编写健壮代码的关键。浅复制可能导致意外的共享状态和内存问题，而深复制则可以确保对象的独立性。在处理包含指针或动态分配内存的对象时，务必考虑使用深复制来避免潜在的...
C++ 深拷贝、赋值拷贝
cj_bigniu的博客
07-07 1681
C++ 深拷贝、赋值拷贝1.类2.深拷贝3.拷贝构造```javascript4.插入元素、删除元素、访问数组 编程环境：VS2017 语言：c++ 实现功能： /**************************************************** 1.可以对内置数据类型以及自定义数据类型的数据进行存储 2.将数组中的数据存储到堆区 3.构造函数中可以传入数组的容量 4.提供对...
【C++】深拷贝与浅拷贝
明朗晨光的专栏
11-01 225
1. 概述 C++中通常用new替代C语言中写的malloc。 为什么使用new呢？ malloc不会自动调用构造函数，但是new会调用构造函数 malloc属于函数，new属于操作符，可以重载 2. 浅拷贝 #include<iostream> using namespace std; class Array { public: Array(int n = 10) { this->n = n; data = new int[n];
C++：深拷贝和浅拷贝
qq_41708281的博客
05-03 370
// xigou_example.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <iostream> using namespace std; class IntArray { public: IntArray(int sz); //构造函数，有参 IntArray(); //构造函数，无参 IntArray(IntArray &x); //深度拷贝函数 void displayArraySize();//显.
C++ 深拷贝实例-改变原生数组
dashen2259的博客
12-12 551
深拷贝 main.cpp 1 #include <stdio.h> 2 #include "IntArray.h" 3 4 int main() 5 { 6 IntArray a(5); 7 8 for(int i=0; i<a.length(); i++) 9 { 10 ...
数组拷贝（深拷贝、浅拷贝）
清风
03-07 1979
Arrays.copyOf() 底层都是使用System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)方法完成数组元素拷贝任务的 方法说明： - 如果newLength &amp;lt; original.length，那么会将原数组中前newLength个元素拷贝到新数组中 - 如果newLength &amp;...
(C++中的浅拷贝和深拷贝)C++中某个类中有成员变量中有指向新开辟的堆空间要自己写构造函数和拷贝构造函数
More reading and learning to become excellent
02-19 315
涉及到浅拷贝和深拷贝 class Car { int m_price; char *m_name; public: Car(int price = 0, const char *name = NULL) :m_price(price){ if (name == NULL) r...
对象数组
wxhpzg123的博客
05-23 322
声明一个对象数组 HashMap[]map1 = new HashMap[10];  for(int i = 0;i map1[i].put("touxiang", R.drawable.touxiang); map1[i].put("nicheng", "荒城旧日"); map1[i].put("content", "fweggwgwgwf"         +" gwgw");
浅拷贝与深拷贝
foooooods的博客
04-26 135
# include<stdio.h> # include <malloc.h> # include<string.h> typedef struct student { int code ; char *s; }LNode; int main() { LNode node; LNode twolnode; no...
C++ 对象数组
u013982161的专栏
10-16 8954
类是对象的抽象，我们可以使用一个类来定义很多的对象，然后每个对象都有自己的属性。 当我们使用类来定义很多相同结构的对象的时候，我们可以采取对象数组的方法。 例如，一个班有50个学生，我们定义了一个学生类，该类的学生具有相同的数据成员和成员函数，我们就可以定义一个这样的数组。 Student stdu[50];//假设已经声明了Student类，定义stud数组，有50个元素
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值