C++动态数组的实现，及类的构成并调用方法 | 数组类的封装

103 阅读 0 评论 68 点赞

我是靠谱客的博主调皮银耳汤，这篇文章主要介绍C++动态数组的实现，及类的构成并调用方法 | 数组类的封装，现在分享给大家，希望可以做个参考。

定义一元素为整数的动态数组类，并在主函数中调用各个功能:

数据成员:指向元素首地址的指针（用于存储动态申请的数组空间)、当前数组的容量、当前元素的个数;

成员函数:

1.带参/无参构造函数(无参的动态申请10个元素空间并改变当前数组的容量、当前元素的个数值;带参的按参数处理);

2.在尾部增加一元素;

3.修改指定位置上的元素值;

4.查询指定数据的元素是否存在;

5.输出所有数组中的元素;

6.增加数组容量(动态申请新容量数组空间、将原来数组空间中的元素复制到新空间并修改当前数组的容量值，释放delete原来数组空间) ;

7.析构函数(释放动态申请的数组空间) ;

8.二分查询指定数据的元素并返回原始所处的位置(选作，首先在函数内定义一个结构体数组，临时存放当前元素值和位置。其次，使用sort函数对结构体数组排序，最后，利用二分(折半)查找方法找指定元素是否存在。存在，返回原始位置值。否则，返回-1。返回前释放结构体数组的空间)。

复制代码

#include<iostream>
#include<string>
#include<algorithm>
#include<math.h>
using namespace std;

struct Array1
{
    int val;
    int index;//将动态数组用结构体保存，val为原始值，index为原始位置
};

class Array
{
    int *p;//地址指针
    int Size;//在动态数组的个数
    int Capacity;//动态数组容量
public:
    Array(int Capacity);//有参构造
    Array();//无参构造
    void add_last(int x);//在尾部增加一个数x
    void change_data(int index,int x);//修改index处的值为x
    void PrintAll();//打印所有元素
    int query(int x);//查询x是否存在于动态数组中，二分查找
    void AddCapacity(Array,int Capacity);//将数组复制到新的空间，并增加数组容量
    ~Array();//析构函数
};

Array::Array(int x)
{
    this->Capacity=x;
    this->Size=0;
    this->p=new int[this->Capacity];//创建堆区数组
}

Array::Array()
{
    Capacity=10;
    this->Size=0;
    this->p=new int[this->Capacity];
}

void Array::add_last(int x)
{
    if(this->Size==this->Capacity)
    {
        return;
    }
    this->p[this->Size]=x;
    this->Size++;
}

void Array::change_data(int index,int x)
{
    this->p[index-1]=x;
}

bool Map(struct Array1 a,struct Array1 b){
     if(a.val<b.val) return true;
     else  return false;
 }//sort排序条件

int Array::query(int x)
{

Array1 arr[1000];
    for(int i=0;i<this->Size;i++)
    {
        arr[i].index=i;arr[i].val=this->p[i];
    }
    sort(arr,arr+this->Size,Map);//按照数组值排序
    //二分查找
    int left=0;int right=this->Size-1;
    while(left<=right)
    {
        int middle=(left+right)/2;
        if(x==arr[middle].val) return arr[middle].index+1;
        if(x>arr[middle].val) left=middle+1;
        else right=middle-1;
    }return -1;
}

void Array::PrintAll()
{
    for(int i=0;i<this->Size;i++)
    {
        cout<<this->p[i]<<" ";
    }cout<<endl;
}

void Array::AddCapacity(Array arr,int x)
{
    this->Capacity=arr.Capacity+x;
    this->Size=arr.Size;
    //this->p=arr->p;  这是浅拷贝，直接把指针与p指向同一个，易发生内存泄漏
    this->p=new int[this->Capacity];//深拷贝，创建新堆区
    for(int i=0;i<arr.Size;i++)
    {
        this->p[i]=arr.p[i];
    }
}

Array::~Array()
{
    delete []this->p;
    this->p=NULL;
    this->Capacity=0;
    this->Size=0;
}

int main()
{
    int n,x;
    cout<<"请输入数组容量：";
    cin>>n;
    Array a(n);
    cout<<"请输入"<<n<<"个元素的值："<<endl;
    for(int i=0;i<n;i++)
    {
        cin>>x;
        a.add_last(x);
    }
    cout<<"打印数组："<<endl;
    a.PrintAll();
    cout<<"将数组的容积增加了10"<<endl;
    a.AddCapacity(a,10);
    cout<<"修改2处的值为77："<<endl;
    a.change_data(2,77);
    a.PrintAll();
    cout<<"查询是否有值等于9并返回所处位置："<<endl;
    cout<<a.query(9)<<endl;
    a.~Array();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include<iostream>
#include<string>
#include<algorithm>
#include<math.h>
using namespace std;

struct Array1
{
    int val;
    int index;//将动态数组用结构体保存，val为原始值，index为原始位置
};

class Array
{
    int *p;//地址指针
    int Size;//在动态数组的个数
    int Capacity;//动态数组容量
public:
    Array(int Capacity);//有参构造
    Array();//无参构造
    void add_last(int x);//在尾部增加一个数x
    void change_data(int index,int x);//修改index处的值为x
    void PrintAll();//打印所有元素
    int query(int x);//查询x是否存在于动态数组中，二分查找
    void AddCapacity(Array,int Capacity);//将数组复制到新的空间，并增加数组容量
    ~Array();//析构函数
};

Array::Array(int x)
{
    this->Capacity=x;
    this->Size=0;
    this->p=new int[this->Capacity];//创建堆区数组
}

Array::Array()
{
    Capacity=10;
    this->Size=0;
    this->p=new int[this->Capacity];
}

void Array::add_last(int x)
{
    if(this->Size==this->Capacity)
    {
        return;
    }
    this->p[this->Size]=x;
    this->Size++;
}

void Array::change_data(int index,int x)
{
    this->p[index-1]=x;
}

 bool Map(struct Array1 a,struct Array1 b){
     if(a.val<b.val) return true;
     else  return false;
 }//sort排序条件


int Array::query(int x)
{

    Array1 arr[1000];
    for(int i=0;i<this->Size;i++)
    {
        arr[i].index=i;arr[i].val=this->p[i];
    }
    sort(arr,arr+this->Size,Map);//按照数组值排序
    //二分查找
    int left=0;int right=this->Size-1;
    while(left<=right)
    {
        int middle=(left+right)/2;
        if(x==arr[middle].val) return arr[middle].index+1;
        if(x>arr[middle].val) left=middle+1;
        else right=middle-1;
    }return -1;
}

void Array::PrintAll()
{
    for(int i=0;i<this->Size;i++)
    {
        cout<<this->p[i]<<" ";
    }cout<<endl;
}

void Array::AddCapacity(Array arr,int x)
{
    this->Capacity=arr.Capacity+x;
    this->Size=arr.Size;
    //this->p=arr->p;  这是浅拷贝，直接把指针与p指向同一个，易发生内存泄漏
    this->p=new int[this->Capacity];//深拷贝，创建新堆区
    for(int i=0;i<arr.Size;i++)
    {
        this->p[i]=arr.p[i];
    }
}

Array::~Array()
{
    delete []this->p;
    this->p=NULL;
    this->Capacity=0;
    this->Size=0;
}

int main()
{
    int n,x;
    cout<<"请输入数组容量：";
    cin>>n;
    Array a(n);
    cout<<"请输入"<<n<<"个元素的值："<<endl;
    for(int i=0;i<n;i++)
    {
        cin>>x;
        a.add_last(x);
    }
    cout<<"打印数组："<<endl;
    a.PrintAll();
    cout<<"将数组的容积增加了10"<<endl;
    a.AddCapacity(a,10);
    cout<<"修改2处的值为77："<<endl;
    a.change_data(2,77);
    a.PrintAll();
    cout<<"查询是否有值等于9并返回所处位置："<<endl;
    cout<<a.query(9)<<endl;
    a.~Array();
}