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

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

成员函数:

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();
}

可以点个免费的赞吗！！！