原型模式——C++实现

向量的原型

用C++完成数学中向量的封装，其中，用指针和动态申请支持向量长度的改变，使用浅克隆和深克隆复制向量类，比较这两种克隆方式的异同。

类图：

 

浅克隆C++代码：

#include <iostream>
using namespace std;
//向量类
class Vector{
private:
    int *p;
    int len;
public:
    Vector(int len);
    Vector(const Vector &vector);  //拷贝构造函数
    ~Vector();
    int operator[](int i) const { return p[i]; }
    int &operator[](int i){ return p[i]; }
    int length() const { return len; }
};
Vector::Vector(int len): len(len){
    p = (int*)calloc( len, sizeof(int) );
}
//拷贝构造函数
Vector::Vector(const Vector &vector){
    this->len = vector.len;
    this->p = vector.p;
}
Vector::~Vector(){ free(p); }
//打印
void display(const Vector &vector){
    int len = vector.length();
    for(int i=0; i<len; i++){
        if(i == len-1){
            cout<<vector[i]<<endl;
        }else{
            cout<<vector[i]<<", ";
        }
    }
}
int main(){
    Vector v1(10);
    for(int i=0; i<10; i++){
        v1[i] = i;
    }
    Vector v2 = v1;
    v2[6] = 55;
    v2[2] = 20;
    cout<<"浅克隆："<<endl;
    cout<<"更改copyVector后vector的数据："<<endl;
    display(v1);
    cout<<"更改copyVector后copyVector的数据："<<endl;
    display(v2);
    return 0;
}

浅克隆运行结果：

深克隆C++代码：

#include <iostream>
using namespace std;
//向量类
class Vector{
private:
    int *p;
    int len;
public:
    Vector(int len);
    Vector(const Vector &vector);  //拷贝构造函数
    ~Vector();
    int operator[](int i) const { return p[i]; }
    int &operator[](int i){ return p[i]; }
    int length() const { return len; }
};
Vector::Vector(int len): len(len){
    p = (int*)calloc( len, sizeof(int) );
}
//拷贝构造函数
Vector::Vector(const Vector &vector){
    this->len = vector.len;
    this->p =  (int*)calloc( this->len, sizeof(int) );
    memcpy( this->p, vector.p, len * sizeof(int) );
}
Vector::~Vector(){ free(p); }
//打印
void display(const Vector &vector){
    int len = vector.length();
    for(int i=0; i<len; i++){
        if(i == len-1){
            cout<<vector[i]<<endl;
        }else{
            cout<<vector[i]<<", ";
        }
    }
}
int main(){
    Vector v1(10);
    for(int i=0; i<10; i++){
        v1[i] = i;
    }
    Vector v2 = v1;
    v2[6] = 55;
    v2[2] = 20;
    cout<<"深克隆："<<endl;
    cout<<"更改copyVector后vector的数据："<<endl;
    display(v1);
    cout<<"更改copyVector后copyVector的数据："<<endl;
    display(v2);
    return 0;
}

深克隆运行结果：

两种克隆方式异同：

1、在C++中，对一个已知对象进行拷贝，系统会自动调用一种构造函数——拷贝构造函数。

2、如果用户未定义拷贝构造函数，则会调用默认拷贝构造函数,这时进行的是浅拷贝（浅克隆）。即对vector拷贝后出现两个指针指向同一个内存空间。

 

 

 

所以在程序中我们改变copyVector的内容，vector中的内容也会改变。 

 

 

 

 

3、若我们自己定义拷贝构造函数，使拷贝后的对象指针有自己的内存空间，即进行深拷贝（深克隆）。

 

 

 

此时改变copyVector的内容，vector中的内容不会改变。

  

 

 

#include <iostream>

using namespace std;

//向量类

class Vector{

private:

    int *p;

    int len;

public:

    Vector(int len);

    Vector(const Vector &vector);  //拷贝构造函数

    ~Vector();

    int operator[](int i) const { return p[i]; }

    int &operator[](int i){ return p[i]; }

    int length() const { return len; }

};

Vector::Vector(int len): len(len){

    p = (int*)calloc( len, sizeof(int) );

}

//拷贝构造函数

Vector::Vector(const Vector &vector){

    this->len = vector.len;

    this->p =  (int*)calloc( this->len, sizeof(int) );

    memcpy( this->p, vector.p, len * sizeof(int) );

}

Vector::~Vector(){ free(p); }

//打印

void display(const Vector &vector){

    int len = vector.length();

    for(int i=0; i<len; i++){

        if(i == len-1){

            cout<<vector[i]<<endl;

        }else{

            cout<<vector[i]<<", ";

        }

    }

}

int main(){

    Vector v1(10);

    for(int i=0; i<10; i++){

        v1[i] = i;

    }

    Vector v2 = v1;

    v2[6] = 55;

    v2[2] = 20;

    cout<<"深克隆："<<endl;

    cout<<"更改copyVector后vector的数据："<<endl;

    display(v1);

    cout<<"更改copyVector后copyVector的数据："<<endl;

    display(v2);

    return 0;

}