C++day7

 仿照vector手动实现自己的myVector,最主要实现二倍扩容功能

代码

头文件

#ifndef TEST_H
#define TEST_H
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
template <typename T>
class Myvector
{
public:
    Myvector();                     //无参构造
    Myvector(int n,const T num);    //有参构造
    Myvector(const Myvector &other);//拷贝构造
    ~Myvector();                    //析构函数
    int capacity();                 //返回当前所能容纳的元素个数
    void push_back(const T &num);   //在末尾插入元素
    int size_data();                //返回当前存储的元素个数
    void assign(int n,const T num); //向容器中赋值
    T& at(int pos);                 //返回指定位置的数据
    void clear();                   //清空
    bool empty();                   //判空
    T& front();                     //返回第一个数据
    T& back();                      //返回最后一个数据
    T* begin();                     //返回第一个数据的地址
    T* end();                       //返回最后一个数据的地址
    T* insert(T* p,const T& num);   //指定位置插入数据
    void pop_back();                //删除最后一个数据
    void show();                    //遍历
private:
    T* data;      //存数据
    int size;     //存储数据个数最大值
    int number;   //存储当前数据个数
};
#endif // TEST_H

源代码

#include "test.h"
template <typename T>
Myvector<T>::Myvector():data(new T),size(1),number(0){}     //无参构造
template <typename T>
Myvector<T>::Myvector(int n,const T num)    //有参构造
{
    //输入了n个数据
    size = n;
    number = n;
    data = new T[n];
    for (int i = 0; i < n; ++i) //将申请到的空间都赋值为num
    {
        data[i] = num;
    }
}
template <typename T>
Myvector<T>::Myvector(const Myvector &other)//拷贝构造
{
    size = other.size;
    data = new T[other.size];
    for (int i = 0; i < other.size; ++i)
    {
        data[i] = other.data[i];
    }
}
template <typename T>
Myvector<T>::~Myvector()                    //析构函数
{
    delete []data;
}
template <typename T>
int Myvector<T>::capacity()     //返回当前所能容纳的元素个数
{
     return size;
}
template <typename T>
void Myvector<T>::push_back(const T &num)      //在末尾插入元素
{
    if(number == size) //判断当前是否已满
    {
        int i = 0;
        T* data_new = new T[size*2];  //二倍扩容
        size = size * 2;
        while(i < number)       //将旧区的数据内容赋给新区
        {
            data_new[i] = data[i];
            i++;
        }
        delete []data;          //释放旧区
        data = data_new;        //指向新区
        data_new = nullptr;     //新指针置空
        data[number] = num;     //插入元素
        number++;               //存储数量加1
    }
    else if(number < size)
    {
        data[number] = num;
        number++;
    }
}
template <typename T>
int Myvector<T>::size_data()       //返回当前存储的元素个数
{
    return number;
}
template <typename T>
void Myvector<T>::assign(int n,const T num) //向容器中赋值
{
    if(n > size) //判断要重写的数据个数是否最大存储个数
    {
        int i = 0;
        while(n > size)
        {   //之前的空间不够，释放并重新给空间
            delete []data;
            data = nullptr;
            data = new T[size*2];  //二倍扩容
            size = size * 2;
        }
        while(i < n)       //循环赋值
        {
            data[i] = num;
            i++;
        }
        number = n;             //存储数量改变
    }
    else if(n < size)
    {
        int i = 0;
        while(i < n)       //循环赋值
        {
            data[i] = num;
            i++;
        }
        if(n > number)  //如果重写个数大于已有个数
        {
            number = n; //更新已有个数
        }
    }
}
template <typename T>
T& Myvector<T>::at(int pos) //返回指定位置的数据
{
    if(pos > number || pos < 0)
    {
        throw T(1);  //抛出异常
    }
    else
    {
        return data[pos-1];  //返回指定位置数据
    }
}
template <typename T>
void Myvector<T>::clear() //清空
{
    memset(data,0,sizeof(data[0])*size);
    number = 0;
}
template <typename T>
bool Myvector<T>::empty()    //判空
{
    return number == 0;
}
template <typename T>
T& Myvector<T>::front() //返回第一个数据
{
    return data[0];
}
template <typename T>
T& Myvector<T>::back() //返回最后一个数据
{
    return data[number-1];
}
template <typename T>
T* Myvector<T>::begin() //返回第一个数据的地址
{
    return &data[0];
}
template <typename T>
T* Myvector<T>::end() //返回最后一个数据的地址
{
    return &data[number];
}
template <typename T>
T* Myvector<T>::insert(T* p,const T& num)   //指定位置插入数据
{
    int j = 0;
    while(&data[0]+j != p) //寻找输入的是第几个数据的地址
    {
        j++;
    }
    if(number == size || j+1 > size) //判断当前是否已满
    {
        int i = 0;
        T* data_new = new T[size*2];  //二倍扩容
        size = size * 2;
        while(i < number)       //将旧区的数据内容赋给新区
        {
            data_new[i] = data[i];
            i++;
        }
        delete []data;          //释放旧区
        data = data_new;        //指向新区
        data_new = nullptr;     //新指针置空
        //将指定位置之后的数据全都后移一位
        for(int k = number,i = j;i < number;i++,k--)
        {
                data[k] = data[k-1];
        }
        data[j] = num;     //插入元素
        number++;               //存储数量加1
        return &data[j];
    }
    else if(number < size && j < size)
    {
        //将指定位置之后的数据全都后移一位
        for(int k = number,i = j;i < number;i++,k--)
        {
                data[k] = data[k-1];
        }
        data[j] = num;     //插入元素
        number++;               //存储数量加1
        return &data[j];
    }
}
template <typename T>
void Myvector<T>::pop_back() //删除最后一个数据
{
    number--;
}
template <typename T>
void Myvector<T>::show() //遍历
{
    int i = 0;
    for(;i < number;i++)
    {
        cout << data[i] << "\t";
    }
    cout << endl;
}

测试函数

#include "test.h"
#include "test.cpp"
int main()
{
    Myvector<int> v1(6,3);
    v1.show();
    cout << "1当前能够容纳的元素个数：" << v1.capacity() << endl;
    v1.push_back(5);       //在末尾插入一个数
    v1.show();
    cout << "最后一个元素：" << v1.at(7) << endl;
    cout << "2当前能够容纳的元素个数：" << v1.capacity() << endl;
    cout << "第一个数：" << v1.front() << endl;
    cout << "最后一个数：" << v1.back() << endl;
    v1.insert(v1.begin()+3,5);      //指定位置插入
    v1.show();
    cout << "3当前能够容纳的元素个数：" << v1.capacity() << endl;
    v1.pop_back();      //删除末尾元素
    v1.show();
    cout << "4当前能够容纳的元素个数：" << v1.capacity() << endl;
    v1.assign(13,1);  //向容器中赋值
    v1.show();
    cout << "5当前能够容纳的元素个数：" << v1.capacity() << endl;
    return 0;
}

运行结果 

思维导图