C++编程训练5

编写一个动态数组类， 要求如下： 1) 编写构造函数、拷贝构造函数、析构函数； 2) 获取任意一个位置的元素； 3) 能够实现数组动态扩容； 4) 删除任意指定位置的元素。

头文件stdafx.h

#ifndef STDAFX__H__INCLUDED
#define STDAFX__H__INCLUDED

#pragma once
#include <iostream>
#include "Array.h"
using namespace std;

#endif // STDAFX__H__INCLUDED

头文件Array.h

#ifndef ARRAY_H_INCLUDED
#define ARRAY_H_INCLUDED
#include "stdafx.h"
template<class T>
class Array
{
    //函数成员
private:
    //动态数组中的元素个数
    int Size = 0;
    //指向动态数组的指针
    T* ptr = nullptr;
    int _ncapacity = 10;

public:
    //无参数构造函数
    Array() :ptr(nullptr), Size(0) {}
    //有参数构造函数，参数为元素个数与元素数值
    Array(int m, T nvalue = 0)
    {
        Size = m > 0 ? m : 1;
        ptr = new T[Size];

        for (int i = 0;i < Size;++i)
        {
            ptr[i] = nvalue;
        }
    }

    //拷贝构造函数
    Array(const Array& obj)
    {
        ptr = new T[obj.Size];
        for (int i = 0;i < obj.Size;++i)
        {
            ptr[i] = obj.ptr[i];
        }
        Size = obj.Size;
    }

    //析构函数，释放空间
    ~Array()
    {
        if (ptr)
        {
            delete[] ptr;
            ptr = nullptr;
        }
    }
    //=运算符的重载
    Array& operator=(const Array& obj)
    {
        if (this->ptr == obj.ptr) { return *this; }
        if (ptr) { delete[] ptr;ptr = nullptr; }
        if (obj.ptr != nullptr)
        {
            T* ptemp = new T[obj.Size];
            for (int i = 0; i < obj.Size; ++i)
            {
                ptemp[i] = obj.ptr[i];
            }
            ptr = ptemp;
        }
        Size = obj.Size;

        return *this;
    }

    //对[]运算符的重载
    T& operator[](int npos)
    {
        return ptr[npos];
    }

public:
    //获取数组元素的个数
    int getLenth()const { return Size; }

    //获取任意一个位置的元素
    T& At(int npos)
    {
        if (npos < 0 || npos > Size - 1)
        {
            throw  1;
        }
        return ptr[npos-1];
    }

    //在数组的最后位置增加元素
    bool pushback(T& nvalue)
    {
        Size += 1;
        //如果原来一个元素都没有，指针为空
        if (ptr == nullptr)
        {
            ptr = new T[Size];
            if (ptr == nullptr) { return false; }
            ptr[0] = nvalue;
        }
        else
        {
            int* ptemp = new T[Size];
            if (ptemp == nullptr) { return false; }
            for (int i = 0; i < Size - 1; ++i)
            {
                ptemp[i] = ptr[i];
            }
            ptemp[Size - 1] = nvalue;

            //释放原有空间
            if (ptr)
            {
                delete[] ptr;
            }
            ptr = ptemp;
            ptemp = nullptr;
        }
    }
    //删除数组中的指定位置元素
    void Delete(int npos)
    {
        Size -= 1;
        for (int i = npos-1;i < Size;++i)
        {
            ptr[i] = ptr[i + 1];
        }
    }
};
#endif // MYARRAY_H_INCLUDED

源文件main.cpp

#include <iostream>
#include "stdafx.h"

int main()
{    //测试
    //定义一个数组，并赋值
    Array<double> a(5);
    for (int i = 0;i < 5;++i)
    {
        a[i] = i;
    }
    //先打印出初始数组
    cout << "初始数组为： ";
    for (int i = 0;i < 5;++i)
    {
        cout << a[i] << "\t";
    }
    cout << endl;

    //获取数组中元素的个数
    cout << "元素的个数为" << a.getLenth() << endl;

    //获取任意位置的元素
    cout << "第1个元素为" << a.At(1) << endl;

    //删除数组中的某个元素
    a.Delete(1);
    //打印删除某个元素后的数组
    cout << "删除第1个元素后的数组为:";
    for (int i = 0;i < a.getLenth();++i)
    {
        cout << a[i] << "\t";
    }
    return 0;
}