动态数组封装实现向量类

定义了一个名为VectorDouble的类，它类似于基类型为double的一个向量类。此类中有一个私有成员变量，它是double类型的动态数组；还有两个int类型的成员变量max_count和count，分别表示向量的容量和向量的长度。
类中包含以下内容：
1. 3个构造函数：一个是默认构造函数，它创建有50个元素的一个动态数组；一个要获取一个int参数的构造函数，该参数指定了初始动态数组中的元素数目；以及一个复制构造函数。
2. 一个析构函数。
3. 赋值操作符=的重载函数。
4. 判断两个对象是否相等==的重载函数，若要相等，count以及数组元素的值必须相等，但max_count不一定相等。
5. 实现行为与向量类同名的成员函数：push_back，capacity，size，reserve和resize。

---

下面类的定义：

class VectorDouble
{
public:
    VectorDouble();
    VectorDouble(int size);
    VectorDouble(const VectorDouble& vectordouble_object);
    ~VectorDouble();
    void operator = (const VectorDouble& right_side_object);
    bool operator == (const VectorDouble& object1);
    double operator[] (int nIndex) const;  //重载下标运算符[]
    void input(istream& ins);
    void output(ostream& outs) const;

    //在向量尾插入一个元素，其值为d；
    void push_back(double d);

    //返回向量在内存中总共可以容纳的元素个数；
    int capacity();

    //返回向量的元素的个数 ；
    int size();

    //将向量的容量扩充至new_max_count，也就是说现在测试capacity()时，返回值为new_max_count；
    void reserve(int new_max_count);

    //将向量现有的元素个数调至count个，多则删，少则补，补的值随机分配；
    void resize(int count);

    //获取向量在位置i的值；
    double value_at(int i);

    //将向量位置i上的值更改为d；
    void change_value_at(double d, int i);
private:
    double *value;
    int max_count, count;
};

1、构造函数的实现

VectorDouble::VectorDouble() : max_count(50)
{
    value = new double[max_count + 1];
    count = 50;
    for(int i = 0; i < count; i++)
        value[i] = i;
}

VectorDouble::VectorDouble(int size) : max_count(size)
{
    value = new double[max_count + 1];
    count = size;
    for(int i = 0; i < size; i++)
        value[i] = i;
}

//复制构造函数
VectorDouble::VectorDouble(const VectorDouble& vectordouble_object) 
{
    max_count = vectordouble_object.max_count;
    count = vectordouble_object.count;
    value = new double[max_count + 1];
    memcpy(value, vectordouble_object.value, count * sizeof(double));
}

2、析构函数的实现

VectorDouble::~VectorDouble()
{
    delete [] value;
}

3、赋值操作符=的重载函数的实现

//重载赋值操作符
void VectorDouble::operator = (const VectorDouble& right_side_object)
{   
    max_count = right_side_object.max_count;
    count = right_side_object.count;
    //先将右侧对象拷贝到临时对象中，然后再销毁左侧对象
    double *temp = new double[max_count + 1];
    memcpy(temp, right_side_object.value, count*sizeof(double));
    delete [] value;
    value = temp; 
}

4、判断两个对象是否相等==的重载函数的实现

bool VectorDouble:: operator == (const VectorDouble& object1)
{
    int count1;
    count1 = object1.count; 
    if(count == count1)
    {
        for(int i = 0; i < count1; i++)
        {
            if(value[i] != object1.value[i])
                return false;
        }
        return true;
    }else 
        return false;   
}

5、实现行为与向量类同名的成员函数的实现
push_back函数

void VectorDouble::push_back(double d)
{
    if(count < max_count)
    {
        value[count] = d;
    }       
    else
    {
        max_count = max_count * 2;
        double *temp = new double[max_count];
        memcpy(temp, value, count * sizeof(double));
        delete [] value;
        value = temp;
        value[count] = d;
    }
    ++count;
}

capacity函数

int VectorDouble::capacity()
{
    return max_count;
}

size函数

int VectorDouble::size() 
{
    return count;
}

reserve函数

void VectorDouble::reserve(int new_max_count)
{
    double *temp = new double[count];
    memcpy(temp, value, count * sizeof(double));
    delete [] value;
    max_count = new_max_count;
    value = new double[max_count + 1];
    value = temp;
    value[count] = '\0';
}

resize函数

void VectorDouble::resize(int new_count)
{
    if(new_count < count)
    {
        for(int i = new_count; i < count; i++)
        {
            value[i] = '\0';
        }
    }
    if( count <= new_count && new_count <= max_count)
    {

        for(int i = count; i < new_count; ++i)
        {
            value[i] = rand();
        }
    }

    if(new_count > max_count)
    {
        max_count = 2 * max_count;
        reserve(max_count);
        for(int i = count; i < new_count; i++)
        {
            value[i] = rand();
        }                
    }
    count = new_count;  
}

虽然没有一一列出类的定义中声明的函数，但是向量类的基本功能实现了，要想像C++定义的向量类功能一样，还有待改进！