设计实现mini_vector中的插入和删除算法，要求在指定位置插入、删除元素

源代码

#ifndef MINI_VECTOR

 

#define MINI_VECTOR

 

#include <iostream>

 

#include "d_except.h" // include exception classes

 

using namespace std;

 

template <typename T>

class miniVector

{

public:

 

miniVector(int size = 0);

// constructor.

// Postconditions: allocates array with size number of elements

// and capacity. elements are initialized to T(), the default

// value for type T

 

miniVector(const miniVector<T>& obj);

// copy constructor

// Postcondition: creates current vector as a copy of obj

 

~miniVector();

// destructor

// Postcondition: the dynamic array is destroyed

 

miniVector& operator= (const miniVector<T>& rhs);

// assignment operator.

// Postcondition: current vector holds the same data

// as rhs

 

T& back();

// return the element at the rear of the vector.

// Precondition: the vector is not empty. if vector

// is empty, throws the underflowError exception

 

const T& back() const;

// const version used when miniVector object is a constant

 

T& operator[] (int i);

// provides general access to elements using an index.

// Precondition: 0 <= i < vSize. if the index is out

// of range, throws the indexRangeError exception

 

const T& operator[] (int i) const;

// const version used when miniVector object is a constant

 

void push_back(const T& item);

// insert item at the rear of the vector.

// Postcondition: the vector size is increased by 1

 

void pop_back();

// remove element at the rear of the vector.

// Precondition: vector is not empty. if the vector is

// empty, throws the underflowError exception

 

int size() const;

// return current list size

 

bool empty() const;

// return true if vector is empty and false otherwise

 

int capacity() const;

// return the current capacity of the vector

void insert(int i,T item);//插入

void remove(int i);//删除

   private:

int vCapacity; // amount of available space

int vSize; // number of elements in the list

T *vArr; // the dynamic array

 

void reserve(int n, bool copy);

// called by public functions only if n > vCapacity. expands

// the vector capacity to n elements, copies the existing

// elements to the new space if copy == true, and deletes

// the old dynamic array. throws the memoryAllocationError

// exception if memory allocation fails

};

 

template <typename T>

void miniVector<T>::insert(int i,T item)

{

if ((i<0) || (i>=vSize)){

throw indexRangeError(

"miniVector: index range error", i, vSize);

}

if (vSize == vCapacity)

{

if (vCapacity == 0){

reserve(1,false);

}else{

reserve(2 * vCapacity, true);

}

}

for(int j=vSize-1;j>i;j--){

vArr[j+1]=vArr[j]; 

}

vArr[i] = item;

vSize++;

}

 

template <typename T>

void miniVector<T>::remove(int i)

{

if ((i<0) || (i>=vSize)){

throw indexRangeError(

"miniVector: index range error", i, vSize);

}

for(int j=i;j<vSize;j++){

        vArr[j]=vArr[j+1];

}

    vSize--; 

}

 

 

// set the capacity to n elements

template <typename T>

void miniVector<T>::reserve(int n, bool copy)

{

T *newArr;

int i;

 

// allocate a new dynamic array with n elements

newArr = new T[n];

if (newArr == NULL)

throw memoryAllocationError(

"miniVector reserve(): memory allocation failure");

 

// if copy is true, copy elements from the old list to the new list

if (copy)

for(i = 0; i < vSize; i++)

newArr[i] = vArr[i];

 

// delete original dynamic array. if vArr is NULL, the vector was

// originally empty and there is no memory to delete

if (vArr != NULL)

delete [] vArr;

 

// set vArr to the value newArr. update vCapacity

vArr = newArr;

vCapacity = n;

}

 

// constructor. initialize vSize and vCapacity.

// allocate a dynamic array of vSize integers

// and initialize the array with T()

template <typename T>

miniVector<T>::miniVector(int size):

vSize(0), vCapacity(0), vArr(NULL)

{

int i;

 

// if size is 0, vSize/vCapacity are 0 and vArr is NULL.

// just return

if (size == 0)

return;

 

// set capacity to size. since we are building the vector,

// copy is false

reserve(size, false);

// assign size to vSize

vSize = size;

 

// copy T() into each vector element

for (i=0;i < vSize;i++)

vArr[i] = T();

}

 

// copy constructor. make the current object a copy of obj.

// for starters, use initialization list to create an empty

// vector

template <typename T>

miniVector<T>::miniVector (const miniVector<T>& obj):

vSize(0), vCapacity(0), vArr(NULL)

{

   int i;

 

// if size is 0, vSize/vCapacity are 0 and vArr is NULL.

// just return

if (obj.vSize == 0)

return;

 

// set capacity to obj.vSize. since we are building the vector,

// copy is false

reserve(obj.vSize, false);

// assign size to obj.vSize

vSize = obj.vSize;

 

// copy items from the obj.vArr to the newly allocated array

for (i = 0; i < vSize; i++)

vArr[i] = obj.vArr[i];

}

 

// destructor. deallocate the dynamic array

template <typename T>

miniVector<T>::~miniVector()

{

if (vArr != NULL)

// de-allocate memory for the array

delete [] vArr;

}

 

// replace existing object (left-hand operand) by

// rhs (right-hand operand)

template <typename T>

miniVector<T>& miniVector<T>::operator= (const miniVector<T>& rhs)

{

   int i;

 

   // check vCapacity to see if a new array must be allocated

   if (vCapacity < rhs.vSize)

// make capacity of current object the size of rhs. don't

// do a copy, since we will replace the old values

reserve(rhs.vSize, false);

 

// assign current object to have same size as rhs

vSize = rhs.vSize;

 

   // copy items from rhs.vArr to vArr

   for (i = 0; i < vSize; i++)

      vArr[i] = rhs.vArr[i];

 

   return *this;

}

 

// check vSize and throw an underflowError exception if the

// value is 0; otherwise return the element vArr[vSize-1]

template <typename T>

T& miniVector<T>::back()

{

if (vSize == 0)

throw underflowError(

"miniVector back(): vector empty");

 

return vArr[vSize-1];

}

 

template <typename T>

const T& miniVector<T>::back() const

{

if (vSize == 0)

throw underflowError(

"miniVector back(): vector empty");

 

return vArr[vSize-1];

}

 

// provides general access to array elements

template <typename T>

T& miniVector<T>::operator[] (int i)

{

if (i < 0 || i >= vSize)

throw indexRangeError(

"miniVector: index range error", i, vSize);

 

return vArr[i];

}

 

// provides general access to array elements. constant version

template <typename T>

const T& miniVector<T>::operator[] (int i) const

{

if (i < 0 || i >= vSize)

throw indexRangeError(

"miniVector: index range error", i, vSize);

 

return vArr[i];

}

 

// insure that list has sufficient capacity,

// add the new item to the list, and increment vSize

template <typename T>

void miniVector<T>::push_back(const T& item)

{

// if space is full, allocate more capacity

if (vSize == vCapacity)

{

if (vCapacity == 0)

// if capacity is 0, set capacity to 1.

// set copy to false because there are

// no existing elements

reserve(1,false);

else

// double the capacity

reserve(2 * vCapacity, true);

}

 

// add item to the list, update vSize

vArr[vSize] = item;

vSize++;

}

 

// if not empty, just decrement the size

template <typename T>

void miniVector<T>::pop_back()

{

if (vSize == 0)

throw underflowError(

"miniVector pop_back(): vector is empty");

 

vSize--;

}

 

template <typename T>

int miniVector<T>::size() const

{

return vSize;

}

 

template <typename T>

bool miniVector<T>::empty() const

{

return vSize == 0;

}

 

template <typename T>

int miniVector<T>:: capacity() const

{

return vCapacity;

}

 

#endif   // MINI_VECTOR

 

#include "stdafx.h"

#include "d_vector.h"

#include <iostream>

using namespace std;

 

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#define random(x) (rand()%x)

 

 

int main()

{

int i,j,n,x,y,z;

miniVector<int> b;

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

b.push_back(random(100));

}

cout<<"10个随机数："<<endl;

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

cout<<b[i]<<" ";

}

cout<<endl;

        cout<<"选择插入位置:"<<endl;

        cin>>x;

        cout<<endl;

        cout<<"选择插入数字:"<<endl;

        cin>>y;

        b.insert(x,y);

        for(i=0;i<11;i++){

cout<<b[i]<<" ";

}

        cout<<endl;

        cout<<"选择删除位置:"<<endl;

        cin>>z;

        b.remove(z);

        for(i=0;i<9;i++){

cout<<b[i]<<" ";

}

    cout<<endl;

return 0;

}