C++数组深入（从上一篇Ada助手获得灵感而写）

已于 2023-09-16 13:55:19 修改
阅读量59 收藏
点赞数 2
CC 4.0 BY-SA版权
文章标签： c++
于 2023-08-22 13:50:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/c5c5c5c5c5/article/details/132426169
本文介绍了C++中的动态数组类设计，包括构造函数动态申请内存、析构函数释放内存，以及深复制与浅复制的概念，展示了如何处理指针成员的复制。还提及了vector作为动态数组的使用方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

动态数组类
如果我们的类中需要使用动态申请的内存空间，并且该空间是依附于对象的，我们一般在该类的构造函

#include<iostream>
#include<cassert>
using namespace std;

class Point{
public:
	Point():x(0),y(0){
		cout<<"Default Constructor called."<<endl; 
	}
	Point(int x,int y):x(x),y(y){
		cout<<"Constructor called."<<endl;
	}
	~Point(){cout<<"Destructor called."<<endl;}
	int getX() const{return x;}
	int getY() const{return y;}
	void move(int newX,int newY){
			x=newX;
			y=newY;
	}
private:
	int x,y;
};

//动态数组类
class ArrayOfPoints{
public:
	ArrayOfPoints(int size):size(size){
		points=new Point[size];
	}
	~ArrayOfPoints(){
		cout<<"Deleting..."<<endl;
		delete[]points;
	}
	//获得下标为index的数组元素
	Point &element(int index){
		assert(index>=0 && index<size);//如果数组下标不会越界，程序中止
		return points[index];//*(points+index) 
	}
private:
	Point *points;
	int size; 
}; 
int main(){
	int count;
	cout<<"Please enter the count of points:";
	cin>>count;
	ArrayOfPoints points(count);
	points.element(0).move(5,10);//通过访问数组元素的成员
	points.element(1).move(15,20);//通过类访问数组元素的成员 
	return 0； 
}

数中去申请空间(new)，在该类的析构函数中释放空间(delete).

动态申请多维数组（难点）
int *p=new int [6];
可以申请一个二维数组吗？
int *p=new int [2][3];
int *p=new int[2];
//int *p=new int [2][3];
在于他们返回的指针类型是不同的
int(*p)[3]=new int[2][3];
p=new int[size][3];
只有 第一维的容量可以使用变量，其他维度必须使用常量.
 

#include<iostream>
using namespace std;
int main(){
	//int *p=new int[2];
	//int *p=new int[2][3];
	int (*p)[3];
	int size=5;
	p=new int[size][3];
	//*(*(p+i)+j)
	//p[i][j]
	
	delete[]p;
} 

#include<iostream>
using namespace std;
int main(){
	float(*cp)[9][8]=new float[8][9][8];
	for(int i=0;i<8;i++)
		for(int j=0;j<8;j++)
			for(int k=0;k<8;k++)
				//以指针形式数组元素
				*(*(*(cp+i)+j)+k)=static cast<float>(i*100+j*10+k);
	for(int i=0;i<8;i++){
		for(int j=0;j<9;j++){
			for(int k=0;k<8;k++)
				//将指针cp作为数组名使用，通过数组名和下标访问数组元素
				cout<<cp[i][j][k]<<" ";
				cout<<endl; 
		}
		cout<<endl;
	} 
	delete[] cp;
	return 0;
}

vector简介
C++标准库中封装好的一个动态数组类
大致的用法:

#include<iostream>
#include<vector>
using namespace std;
int main(){
	int b[]={3,4,5};
	vector<int>a(b,b+3);
	cout<<a.size()<<endl;
	a.push_back(6);
	cout<<a[0]<<endl;
	cout<<a.size()<<endl;
}

#include<iostream>
#include<vector>
using namespace std;
//计算数组arr中元素的平均值
double average(const vector<double>&arr){
	double sum=0;
	for(unsigned i=0;i<arr.size();i++)
		sum+=arr[i];
		return sum/arr.size(); 
}

int main(){
	unsigned n;
	cout<<"n=";
	cin>>n;
	vector<double> arr(n);//创建数组对象
	cout<<"Please input"<<n<<"real numbers:"<<endl;
	for(unsigned i=0;i<n;i++)
		cin>>arr[i];//运算符重载
		cout<<"Average="<<average(arr)<<endl; 
	return 0;
}

深复制与浅复制（重点）
当类的成员中含有指针数据成员的时候，通过复制构造来创建新的对象可能会遇到问题.为什么？使用默认的复制构造函数，完成的是无修改的复制，会导致不同对象的指针成员指向同一块内存空间（往往和实际需求不符），这种复制，我们称其为浅复制.
如何解决这个问题？
使用深复制，自定义复制构造函数，控制复制构造的过程.

#include<iostream>
#include<cassert>
using namespace std;

class Point{
public:
	Point():x(0),y(0){
		cout<<"Point"<<endl;
	}
	Point(int x,int y):x(x),y(y){
		cout<<"Point"<<endl;
	}
	~Point(){cout<<"~Point"<<endl;}
	int getX()const{return x;}
	int getY()const{return y;}
	void move(int newX,int newY){
		x=newX;
		y=newY;
	}
private:
	int x,y;
};
//动态数组类
class ArrayOfPoints{
public:
	ArrayOfPoints(int size):size(size){
		cout<<"ArrayOfPoints"<<endl;
		points=new Points[size];
	}
	ArrayOfPoints(ArrayOfPoints &aps){
		cout<<"ArrayOfPoints Copy"<<endl;
		size=aps.size;
		points=new Point[size];
		for(int i=0;i<size;i++){
			points[i]=aps.points[i];
		}
	}
	~ArrayOfPoints(){
		cout<<"Deleting..."<<endl;
		delete[]points;
		cout<<"~ArrayOfPoints"<<endl;
	}
	//获得下标为index的数组元素
	Point &element(int index){
		assert(index>=0 && index<isze);
		return points[index];//*(points+index)
	}
private:
	Point *points;//指向动态数组首地址
	int size; 
};
int main(){
	int count=2;
	//cout<<"Please enter the count of points:";
	//cin>>count;
	ArrayOfPoints points1(count);//创建对象数组
	points1.element(0).move(5,10);//通过访问数组元素的成员
	points1.element(1).move(15,20);//通过类访问数组元素的成员
	
	ArrayOfPoints points2(points2);
	return 0; 
} 

#include<iostream>
#include<cassert>
using namespace std;
class Point{
public:
	Point():x(0),y(0){
		cout<<"Default Constructor called."<<endl;
	}
	POint(int x,int y):x(x),y(y){
		cout<<"Constructor called."<<endl;
	}
	~Point(){cout<<"Destructor called."<<endl;}
	int getX()const{return x;}
	int getY()const{return y;}
	void move(int newX,newY){
		x=newX;
		y=newY;
	}
private:
	int x,y;
};
//动态数组类
class ArrayOfPoints{
public:
	ArrayOfPoints(int size):size(size){
		points=new Point[size];
	}
	~ArrayOfPoints(){
		cout<<"Deleting..."<<endl;
		delete[]points;
	}
	//获得下标为index的数组元素
	Point &element(int index){
		assert(index>=0 && index<size);//若果数组下标不会越界，程序中止
		return points[index]; 
	}
private:
Point *points;//指向动态数组首地址
int size;//数组大小 
};
int main(){
	int count;
	cout>>"Please enter the count of points:";
	cin>>count;
	ArrayOfPoints pointsArray1(count);//创建对象数组
	pointsArray1.element(0).move(5,10);
	pointsArray1.element(1).move(15,20);
	ArrayOfPoints pointsArray2=pointsArray1;//创建对象数组副本
	cout<<"Copy of pointsArray1:"<<endl;
	cout<<"Points_0 of array2:"<<pointsArray2.element(0).getX()<<","<<pointsArray2.element(0).getY()<<endl;
	cout<<"Points_1 of array2:"<<pointsArray2.element(0).getX()<<","<<pointsArray2.element(1).getY()<<endl;
	pointsArray1.element(0).move(25,30);
	pointsArray1.element(1).move(35,40);
	cout<<"After the moving of pointsArray1:"<<endl;
	cout<<"Points_0 of array2:"<<pointsArray2.element(0).getX()<<","<<pointsArray2.element(0).getY()<<endl;
	cout<<"Points_1 of array2:"<<pointsArray2.element(0).getX()<<","<<pointsArray2.element(1).getY()<<endl
	return 0;
}

动态数组类：简单版

#include<iostream>
#include<cassert>
using namespace std;
class Point{
public:
	Point():x(0),y(0){
		cout<<"Default Constructor called."<<endl;
	}
	Point(int x,int y):x(x),y(y){
		cout<<"Constructor called."<<endl;
	}
	~Point(){cout<<"Destructor called."<<endl;}
	int getX()const{return x;}
	int getY()const{return y;}
	voidmove(int newX,int newY){
			x=newX;
			y=newY;
	}
private:
	int x,y;
}; 
//动态数组类
class ArrayOfPoints{
public:
	ArrayOfPoints(int size):size(size){
		poinnts=new Point[size];
	}
	~ArrayOfPoints(){
		cout<<"Deleting..."<<endl;
		delete[]points;
	}
	//获得下标为index的数组元素
	Point &element(int index){
		assert(index>=0 && index<size);//如果数组下标不会越界，程序中止
		return points[index]; 
	} 
private:
	Point *points;//指向动态数组首地址
	int size;//数组大小 
};
int main(){
	int count;
	cout<<"Please enter the count of points:";
	cin>>count;
	ArrayOfPoints points(count);//创建对象数组
	points.element(0).move(5,10);//通过访问数组元素的元素
	points.element(1).move(15,20);//通过类访问数组元素的元素
	return 0; 
}

评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值