void CArray::push_back(int v) { //在数组尾部添加一个元素 if (ptr) { int* tmpPtr = new int[size + 1]; //重新分配空间 memcpy(tmpPtr, ptr, sizeof(int) * size); //拷贝原数组内容 delete[] ptr; ptr = tmpPtr; } else //数组本来是空的 ptr = new int[1]; ptr[size++] = v; //加入新的数组元素 }请问调用成员函数push_back(int v)如何扩展数组大小？

调用成员函数 push_back(int v) 会先判断数组是否为空，如果不为空，则新建一个大小为 size+1 的临时数组 tmpPtr，然后将原数组 ptr 的内容复制到 tmpPtr 中，接着删除原数组 ptr，最后将 tmpPtr 赋值给 ptr，相当于扩展了数组的大小。如果数组本来就是空的，则直接新建一个大小为 1 的数组 ptr，并将新元素加入其中。最后，无论是哪种情况，都会将新元素 v 加入数组的最后一个位置，即 ptr[size++] = v。

相关问题

[选做]下面是一个数组类CArray的定义。要求： （1）在此基础上增加print()成员函数打印数组， （2）重载“=”、“+”、“-” 运算符使之能对该数组类对象进行赋值、加减运算。 （3）写出主函数对该类进行测试。 class CArray {private: int* p_arr; int size; public: CArray(); //缺省构造函数 CArray(int* p_a,int s); //构造函数 CArray(const CArray &r_other);//复制构造函数 ~CArray();//析构函数 int operator[](int pos) const; //访问数组元素值的下标运算符重载函数 int& operator[](int pos); //设置数组元素值的下标运算符重载函数 CArray &operator=(const CArray &other)//赋值运算符“=”重载函数 CArray operator+(const CArray &other) //加运算符“+”重载函数 CArray operator-(const CArray &other) //减运算符“-”重载函数 void print() const; }; CArray:: CArray() { p_arr=NULL; size=0;} CArray:: CArray(int* p_a,int s) { if(s>0) { size=s; p_arr=new int[size]; for(int i=0;i<size;i++) p_arr[i]=p_a[i]; } Else { p_arr=NULL; size=0; } } CArray::CArray(const CArray &r_other) { size=r_other.size; if(size) { p_arr=new int[size]; for(int i=0;i<size;i++) p_arr[i]=r_other.p_arr[i]; } } CArray::~CArray() { if(p_arr) delete[] p_arr; p_arr=NULL; size=0; } int CArray::operator[](int pos) const { if(pos>=size) return p_arr[size-1]; if(pos<0) return p_arr[0]; return p_arr[pos]; } int& CArray::operator[](int pos) { if(pos>=size) return p_arr[size-1]; if(pos<0) return p_arr[0]; return p_arr[pos]; }

好的，下面是修改后的CArray类的实现：

#include <iostream>
using namespace std;

class CArray {
private:
    int* p_arr;
    int size;

public:
    CArray(); // 缺省构造函数
    CArray(int* p_a, int s); // 构造函数
    CArray(const CArray& r_other); // 复制构造函数
    ~CArray(); // 析构函数
    int operator[](int pos) const; // 访问数组元素值的下标运算符重载函数
    int& operator[](int pos); // 设置数组元素值的下标运算符重载函数
    CArray& operator=(const CArray& other); // 赋值运算符“=”重载函数
    CArray operator+(const CArray& other); // 加运算符“+”重载函数
    CArray operator-(const CArray& other); // 减运算符“-”重载函数
    void print() const;
};

CArray::CArray() {
    p_arr = NULL;
    size = 0;
}

CArray::CArray(int* p_a, int s) {
    if (s > 0) {
        size = s;
        p_arr = new int[size];
        for (int i = 0; i < size; i++)
            p_arr[i] = p_a[i];
    }
    else {
        p_arr = NULL;
        size = 0;
    }
}

CArray::CArray(const CArray& r_other) {
    size = r_other.size;
    if (size) {
        p_arr = new int[size];
        for (int i = 0; i < size; i++)
            p_arr[i] = r_other.p_arr[i];
    }
}

CArray::~CArray() {
    if (p_arr)
        delete[] p_arr;
    p_arr = NULL;
    size = 0;
}

int CArray::operator[](int pos) const {
    if (pos >= size)
        return p_arr[size - 1];
    if (pos < 0)
        return p_arr[0];
    return p_arr[pos];
}

int& CArray::operator[](int pos) {
    if (pos >= size)
        return p_arr[size - 1];
    if (pos < 0)
        return p_arr[0];
    return p_arr[pos];
}

CArray& CArray::operator=(const CArray& other) {
    if (this == &other)
        return *this;
    if (p_arr)
        delete[] p_arr;
    size = other.size;
    if (size) {
        p_arr = new int[size];
        for (int i = 0; i < size; i++)
            p_arr[i] = other.p_arr[i];
    }
    else {
        p_arr = NULL;
    }
    return *this;
}

CArray CArray::operator+(const CArray& other) {
    int new_size = size + other.size;
    int* new_p_arr = new int[new_size];
    for (int i = 0; i < size; i++)
        new_p_arr[i] = p_arr[i];
    for (int i = 0; i < other.size; i++)
        new_p_arr[size + i] = other.p_arr[i];
    CArray new_array(new_p_arr, new_size);
    delete[] new_p_arr;
    return new_array;
}

CArray CArray::operator-(const CArray& other) {
    int new_size = size;
    int* new_p_arr = new int[new_size];
    for (int i = 0; i < size; i++)
        new_p_arr[i] = p_arr[i];
    for (int i = 0; i < other.size; i++) {
        for (int j = 0; j < new_size; j++) {
            if (new_p_arr[j] == other.p_arr[i]) {
                for (int k = j; k < new_size - 1; k++)
                    new_p_arr[k] = new_p_arr[k + 1];
                new_size--;
                break;
            }
        }
    }
    CArray new_array(new_p_arr, new_size);
    delete[] new_p_arr;
    return new_array;
}

void CArray::print() const {
    for (int i = 0; i < size; i++)
        cout << p_arr[i] << " ";
    cout << endl;
}

int main() {
    int arr1[] = { 1, 2, 3 };
    int arr2[] = { 2, 3, 4 };
    CArray a(arr1, 3);
    CArray b(arr2, 3);
    CArray c = a + b;
    CArray d = a - b;
    c.print();
    d.print();
    return 0;
}

在主函数中对CArray类进行了测试，输出结果为：

1 2 3 2 3 4
1

符合要求。

设计一个动态整型数组类 CArray ，并对CArray类进行测试 ‎ 数据成员： ‎ int *vec; // 动态数组指针 ‎ int size; //动态数组规模 ‎ 成员函数：public ‎ CArray(int n); // 构造函数，构造规模为n的数组 ‎ CArray (CArray &arr); //拷贝构造函数 ‎ ~CArray(); //析构函数，释放动态数组空间 ‎ int length(); // 取数组元素个数 ‎ int get(int i); // 取数组第i个元素 ‎ void set(int i, int value); // 设置数组第i个元素 ‎ int getMax(); // 取数组最大元素 ‎ int getMin(); // 取数组最大元素 ‎ void print(); //输出动态数组的所有元素 ‎ int & operator[](int); ‎ CArray & operator=( const CArray &arr);

下面是 CArray 类的实现：

#include <iostream>
using namespace std;

class CArray {
private:
    int *vec;           // 动态数组指针
    int size;           // 动态数组规模
public:
    CArray(int n) {     // 构造函数，构造规模为n的数组
        vec = new int[n];
        size = n;
    }
    CArray(CArray &arr) {  // 拷贝构造函数
        size = arr.size;
        vec = new int[size];
        for (int i = 0; i < size; i++) {
            vec[i] = arr.vec[i];
        }
    }
    ~CArray() {         // 析构函数，释放动态数组空间
        delete[] vec;
    }
    int length() {      // 取数组元素个数
        return size;
    }
    int get(int i) {    // 取数组第i个元素
        return vec[i];
    }
    void set(int i, int value) {    // 设置数组第i个元素
        vec[i] = value;
    }
    int getMax() {      // 取数组最大元素
        int max = vec[0];
        for (int i = 1; i < size; i++) {
            if (vec[i] > max) {
                max = vec[i];
            }
        }
        return max;
    }
    int getMin() {      // 取数组最小元素
        int min = vec[0];
        for (int i = 1; i < size; i++) {
            if (vec[i] < min) {
                min = vec[i];
            }
        }
        return min;
    }
    void print() {      // 输出动态数组的所有元素
        for (int i = 0; i < size; i++) {
            cout << vec[i] << " ";
        }
        cout << endl;
    }
    int& operator[](int i) {    // 重载 [] 运算符
        return vec[i];
    }
    CArray& operator=(const CArray &arr) {  // 重载 = 运算符
        if (vec == arr.vec) {           // 防止自我赋值
            return *this;
        }
        delete[] vec;                   // 释放原有空间
        size = arr.size;
        vec = new int[size];            // 分配新空间
        for (int i = 0; i < size; i++) {  // 复制元素
            vec[i] = arr.vec[i];
        }
        return *this;
    }
};

测试代码：

int main() {
    CArray a(5);
    for (int i = 0; i < a.length(); i++) {
        a[i] = i + 1;
    }
    a.print();          // 1 2 3 4 5

    CArray b(a);
    b.print();          // 1 2 3 4 5

    CArray c(3);
    c = a;
    c.print();          // 1 2 3

    cout << a.getMax() << endl;     // 5
    cout << a.getMin() << endl;     // 1

    return 0;
}