11.15

[实验任务一]：向量的原型
用C++完成数学中向量的封装，其中，用指针和动态申请支持向量长度的改变，使用浅克隆和深克隆复制向量类，比较这两种克隆方式的异同。
实验要求：

1. 画出对应的类图；

2. 

3. 提交源代码（用C++完成）；

#include <iostream>
using namespace std;

// 抽象原型类
class Prototype {
public:
    virtual ~Prototype() {}
    virtual Prototype* clone() = 0;  // 纯虚函数，定义克隆接口
};

// 具体原型类 - 向量类
class Vector : public Prototype {
private:
    int* data;
    int size;

public:
    // 构造函数
    Vector(int n = 0) : size(n) {
        data = (n > 0) ? new int[n] : nullptr;
        // 初始化数组元素为0
        for (int i = 0; i < size; i++) {
            data[i] = 0;
        }
    }

    // 拷贝构造函数（深拷贝）
    Vector(const Vector& v) : size(v.size) {
        data = (size > 0) ? new int[size] : nullptr;
        for (int i = 0; i < size; i++) {
            data[i] = v.data[i];
        }
    }

    // 析构函数
    ~Vector() {
        delete[] data;
    }

    // 设置元素值
    void setData(int index, int value) {
        if (index >= 0 && index < size) {
            data[index] = value;
        }
    }

    // 获取元素值
    int getData(int index) const {
        if (index >= 0 && index < size) {
            return data[index];
        }
        return 0;
    }

    // 获取向量大小
    int getSize() const {
        return size;
    }

    // 改变向量大小
    void resize(int newSize) {
        if (newSize == size) return;

        int* newData = (newSize > 0) ? new int[newSize] : nullptr;
        int minSize = (newSize < size) ? newSize : size;
        
        // 复制原有数据
        for (int i = 0; i < minSize; i++) {
            newData[i] = data[i];
        }
        // 初始化新增的元素
        for (int i = minSize; i < newSize; i++) {
            newData[i] = 0;
        }

        delete[] data;
        data = newData;
        size = newSize;
    }

    // 浅克隆：实现clone方法
    Vector* shallowClone() {
        Vector* newVector = new Vector();
        newVector->data = this->data;  // 直接复制指针
        newVector->size = this->size;
        return newVector;
    }

    // 深克隆：实现clone方法（使用拷贝构造函数）
    Vector* clone() override {
        return new Vector(*this);  // 调用拷贝构造函数实现深拷贝
    }

    // 打印向量内容
    void print() const {
        cout << "向量大小: " << size << ", 元素内容: ";
        for (int i = 0; i < size; i++) {
            cout << data[i] << " ";
        }
        cout << endl;
    }
};

// 客户端代码
class Client {
private:
    Prototype* prototype;
    Prototype* copy;

public:
    void operation() {
        cout << "----------- 开始测试原型模式 -----------" << endl;
        Vector* v1 = new Vector(3);
        v1->setData(0, 1);
        v1->setData(1, 2);
        v1->setData(2, 3);

        cout << "原始向量:" << endl;
        v1->print();

        // 深克隆测试
        cout << "\n【深克隆测试】" << endl;
        Vector* v2 = static_cast<Vector*>(v1->clone());
        cout << "修改克隆向量的第一个元素为10" << endl;
        v2->setData(0, 10);  // 修改克隆后的向量
        cout << "修改后的结果:" << endl;
        cout << "原始向量: ";
        v1->print();
        cout << "克隆向量: ";
        v2->print();

        // 浅克隆测试
        cout << "\n【浅克隆测试】" << endl;
        Vector* v3 = v1->shallowClone();
        cout << "修改克隆向量的第二个元素为20" << endl;
        v3->setData(1, 20);  // 修改克隆后的向量
        cout << "修改后的结果:" << endl;
        cout << "原始向量: ";
        v1->print();
        cout << "克隆向量: ";
        v3->print();

        cout << "\n【结果分析】" << endl;
        cout << "深克隆: 原始向量与克隆向量相互独立，修改克隆向量不会影响原始向量" << endl;
        cout << "浅克隆: 原始向量与克隆向量共享数据，修改克隆向量会影响原始向量" << endl;

        // 清理内存
        delete v1;
        delete v2;
        // 注意：v3不能删除，因为它共享了v1的数据
        cout << "\n----------- 测试结束 -----------" << endl;
    }
};

int main() {
    Client client;
    client.operation();
    return 0;
}

3.注意编程规范。