c++&qt_day08

作业1

题目

仿 vertor，手写一个 MyVector容器

效果

代码

main.cpp

#include "MyVector.h"

int main(int argc, char const *argv[])
{
    auto show = [](MyVector<int> &mv) -> void {
        for (int i = 0; i < mv.size(); i++) {
            cout << mv[i] << " ";
        }
        cout << endl;
    };

    // 无参构造
    MyVector<int> mv;
    for (int i = 0; i < 10; i++) {
        mv.push_back(rand() % 10);
    }
    show(mv);
    cout << "个数 = " << mv.size() << endl;
    cout << "容量 = " << mv.capacity() << endl;

    // 有参构造
    MyVector<int> mv2(10, 999);
    cout << "=========================" << endl;
    show(mv2);
    cout << "个数 = " << mv.size() << endl;
    cout << "容量 = " << mv.capacity() << endl;

    // 拷贝构造
    cout << "=========================" << endl;
    MyVector<int> mv3 = mv;
    mv3.pop_back();
    show(mv3);
    cout << "个数 = " << mv3.size() << endl;
    cout << "容量 = " << mv3.capacity() << endl;
    cout << "front = " << mv3.front() << endl;
    cout << "back = " << mv3.back() << endl;
    
    cout << "=========================" << endl;
    mv3.clear();
    show(mv3);

    return 0;
}

MyVector.h

#ifndef _MYVECTOR_H_
#define _MYVECTOR_H_

#include <cstring>
#include <iostream>

using namespace std;

template <typename T>
class MyVector
{
   private:
    void expand();  // 二倍扩容数组

   public:
    MyVector();                                     // 无参构造
    MyVector(int size, const T &val);               // 有参构造
    MyVector(MyVector &from);                       // 拷贝构造
    ~MyVector();                                    // 析构函数
    MyVector<T> &operator&=(const MyVector &from);  // =重载
    T &operator[](int pos);                         // []重载
    T &at(int pos);                                 // 下标访问
    int size();                                     // 元素长度
    int capacity();                                 // 数组容量
    bool empty();                                   // 判空
    bool full();                                    // 判满
    T &front();                                     // 首元素
    T &back();                                      // 尾元素
    void clear();                                   // 清空数组
    void push_back(const T &val);                   // 尾插
    void pop_back();                                // 尾删

   private:
    T *begin;
    T *end;
    T *last;
};

/**
 * @brief    无参构造
 * @param    无
 * @return   无
 */
template <typename T>
MyVector<T>::MyVector() : begin(nullptr), end(begin), last(end)
{
}

/**
 * @brief    拷贝构造
 * @param    arr 用来初始化的数组
 * @return   无
 */
template <typename T>
MyVector<T>::MyVector(MyVector &from)
{
    this->begin = new T[from.size()];
    this->end = this->begin + from.size();
    this->last = end;
    memcpy(this->begin, from.begin, (from.end - from.begin) * sizeof(T));
}

/**
 * @brief    有参构造
 * @param    size 大小
 * @param    val 用来初始化的值
 * @return   无
 */
template <typename T>
MyVector<T>::MyVector(int size, const T &val)
{
    this->begin = new T[size];
    this->end = this->begin + size;
    this->last = end;
    for (int i = 0; i < size; i++) {
        this->begin[i] = val;
    }
}

/**
 * @brief    =重载
 * @param    from 用来初始化的MyVector对象
 * @return   初始化后的对象
 */
template <typename T>
MyVector<T> &MyVector<T>::operator&=(const MyVector &from)
{
    if (this->begin)
        delete (this->begin);
    this->begin = new T[from.size()];
    this->end = this->begin + from.size();
    this->last = end;
    for (int i = 0; i < from.size(); i++) {
        this->begin[i] = from.begin[i];
    }
    return *this;
}

/**
 * @brief    析构函数
 * @param    无
 * @return   无
 */
template <typename T>
MyVector<T>::~MyVector()
{
    if (this->begin)
        delete (this->begin);
    this->begin = nullptr;
    this->end = begin;
    this->last = begin;
}

/**
 * @brief    []重载
 * @param    pos 数组下标
 * @return   下标对应元素
 */
template <typename T>
T &MyVector<T>::operator[](int pos)
{
    return begin[pos];
}

/**
 * @brief    按下标访问
 * @param    pos 数组下标
 * @return   下标对应元素
 */
template <typename T>
T &MyVector<T>::at(int pos)
{
    return begin[pos];
}

/**
 * @brief    判空
 * @param    无
 * @return   空返回ture 非空返回false
 */
template <typename T>
bool MyVector<T>::empty()
{
    return !(this->end - this->begin);
}

/**
 * @brief    判满
 * @param    无
 * @return   满返回ture 非满返回false
 */
template <typename T>
bool MyVector<T>::full()
{
    return !(this->end - this->last);
}

/**
 * @brief    首元素
 * @param    无
 * @return   返回数组首元素
 */
template <typename T>
T &MyVector<T>::front()
{
    return *this->begin;
}

/**
 * @brief    尾元素
 * @param    无
 * @return   返回数组尾元素
 */
template <typename T>
T &MyVector<T>::back()
{
    return *(this->last - 1);
}

/**
 * @brief    清空数组
 * @param    无
 * @return   无
 */
template <typename T>
void MyVector<T>::clear()
{
    memset(this->begin, 0, (this->last - this->begin) * sizeof(T));
    this->last = this->begin;
}

/**
 * @brief    元素长度
 * @param    无
 * @return   无
 */
template <typename T>
int MyVector<T>::size()
{
    return this->last - this->begin;
}

/**
 * @brief    数组容量
 * @param    无
 * @return   无
 */
template <typename T>
int MyVector<T>::capacity()
{
    return this->end - this->begin;
}

/**
 * @brief    二倍扩容数组
 * @param    无
 * @return   无
 */
template <typename T>
void MyVector<T>::expand()
{
    int size = this->end - this->begin;
    T *tmp = new T[2 * size];
    memcpy(tmp, begin, size * sizeof(T));
    // 重新指向
    delete[] (this->begin);
    this->begin = tmp;
    this->end = this->begin + 2 * size;
    this->last = this->begin + size;
}

/**
 * @brief    尾插
 * @param    val 要插入的值
 * @return   无
 */
template <typename T>
void MyVector<T>::push_back(const T &val)
{
    // 空数组开辟空间
    if (this->begin == nullptr) {
        this->begin = new T;
        this->end = begin + 1;
        this->last = begin;
    }

    // 非空数组满扩容
    if (this->full())
        this->expand();

    // 赋值
    *this->last = val;
    this->last++;
}

/**
 * @brief    尾删
 * @param    无
 * @return   无
 */
template <typename T>
void MyVector<T>::pop_back()
{
    memset(this->last, 0, sizeof(T));
    this->last--;
}

#endif  //_MYVECTOR_H_