C++ 实现vector<std:string> 版本

#include <iostream>
#include <vector>
#include <memory>
#include <thread>
#include <type_traits>
#include <typeinfo>
#include <sstream>
#include <utility>


class StrVec
{
    friend std::ostream &operator<<(std::ostream &os, const StrVec &rhs);

private:
    std::string *elemnets_;
    std::string *memry_free;
    std::string *cap;
    std::allocator<std::string> alloc;//为所有StrVec分配内存

    //申请2倍范围空间，并把范围移动到新空间
    std::pair<std::string *, std::string *> alloc_n_copy(const std::string *beg, const std::string *end)
    {
        auto new_memry = alloc.allocate(end - beg);
        return {new_memry, std::uninitialized_copy(beg, end, new_memry)};
    };


    void free() //释放目前申请的内存
    {
        for (auto ptr = memry_free; ptr != elemnets_;)
        {
            alloc.destroy(--ptr);
        }

        alloc.deallocate(elemnets_, memry_free - elemnets_);
    }

    void realloctor()  //重新申请大于目前2倍空间;
    {
        auto newcapacity = size() ? 2 * size() : 1;
        auto newmemery = alloc.allocate(newcapacity);
        auto dest = newmemery;
        auto elem = elemnets_;//指向当前对象的头
        for (size_t i = 0; i != size(); ++i)
        {
            //move会让elem指向的string对象放弃自己的内存管理权并返回，然后construct使用string的移动构造函数构建dest指向的地址
            alloc.construct(dest++, std::move(*elem++));
        }
        free();
        elemnets_ = newmemery;
        memry_free = dest;
        cap = elemnets_ + newcapacity;
    };

    void Chk_n_alloc()
    {
        if (size() == capacity())
            realloctor();
    }

public:
    StrVec() : elemnets_(nullptr), memry_free(nullptr), cap(nullptr)
    {}

    StrVec(std::initializer_list<std::string> li)
    {
        auto newadress = alloc_n_copy(li.begin(), li.end());
        elemnets_ = newadress.first;
        cap = memry_free = newadress.second;
    }

    //只是构造(每次想着释放- -)
    StrVec(const StrVec &rhs)
    {
        auto newadress = alloc_n_copy(rhs.begin(), rhs.end());
        elemnets_ = newadress.first;
        cap = memry_free = newadress.second;
    }

    StrVec(StrVec &&rhs)
            : elemnets_(rhs.elemnets_), memry_free(rhs.memry_free), cap(rhs.cap)
    {
        //置空
        rhs.elemnets_ = rhs.cap = rhs.memry_free = nullptr;
    }

    StrVec &operator=(const StrVec &rhs)
    {
        if (&rhs != this)
        {
            auto newadress = alloc_n_copy(rhs.begin(), rhs.end());
            free();
            elemnets_ = newadress.first;
            memry_free = cap = newadress.second;
        }
        return *this;
    }

    StrVec &operator=(StrVec &&rhs)
    {
        if (&rhs != this)
        {
            elemnets_ = rhs.elemnets_;
            memry_free = rhs.memry_free;
            cap = rhs.cap;
            rhs.elemnets_ = rhs.cap = rhs.memry_free = nullptr;
        }
        return *this;
    }

    //列表赋值初始化
    StrVec &operator=(std::initializer_list<std::string> li)
    {
        auto newadress = alloc_n_copy(li.begin(), li.end());
        free();
        elemnets_ = newadress.first;
        memry_free = cap = newadress.second;

        return *this;
    }


    std::string &operator[](std::size_t size_)
    {
        return elemnets_[size_];
    }

    std::string &operator[](std::size_t size) const
    {
        return elemnets_[size];

    }


    bool operator==(const StrVec &s)
    {
        if (size() != s.size())
            return false;
        auto it = elemnets_, its = s.elemnets_;
        while (it != memry_free)
        {
            if (*it++ != *its++)
                return false;
        }
        return true;
    }


    bool operator<(const StrVec &rhs)
    {
        if (this->size() < rhs.size())
        {
            return true;
        } else if (this->size() > rhs.size())
        {
            return false;
        }

        auto rhs_elemte = rhs.elemnets_;
        for (auto iter_ptr = elemnets_; iter_ptr != memry_free;)
        {
            if (*iter_ptr++ > *rhs_elemte++)
            {
                return false;
            } else
            {
                return true;
            }
        }
        return false;
    }

    bool operator>(const StrVec &rhs)
    {
        return !(*this < rhs) && (this != &rhs);
    }

    bool operator!=(const StrVec &rhs)
    {
        return !(*this == rhs);
    }


public:
    template<typename ...Args>
    void emplace_back(Args &&... paracage)
    {
        Chk_n_alloc();
        alloc.construct(memry_free++, std::forward<Args>(paracage)...);
    }

    void push_back(const std::string &s)
    {
        Chk_n_alloc();//确保空间剩余
        alloc.construct(memry_free++, s);//在尾后构建一个s（s的拷贝构造函数构造），并把尾后指针first_free指向下一个
    }

    void pop_back()
    {
        if (memry_free != elemnets_)
        {
            alloc.destroy(--memry_free);
        }
    }


    std::size_t size() const
    {
        return memry_free - elemnets_;
    }

    std::size_t capacity() const
    {
        return cap - elemnets_;
    }

    std::string *begin() const
    {
        return elemnets_;
    }

    std::string *end() const
    {
        return memry_free;
    }
};


std::ostream &operator<<(std::ostream &os, const StrVec &rhs)
{
    for (auto ptr = rhs.elemnets_; ptr != rhs.memry_free;)
    {
        os << *ptr++ << "
";
    }

    return os;
}


int main(int argc, char *argv[])
{

    StrVec strvec{"Hello", "World", "this", "std::string", "vector<std::string>"};
    std::cout << strvec;
    std::cout << strvec[3] << std::endl;
    strvec.push_back("你好");
    std::cout << strvec[5] << std::endl;

    std::cout << "------------" << std::endl;
    std::cout << strvec;
    strvec.pop_back();
    strvec.pop_back();
    strvec.pop_back();
    strvec.pop_back();
    std::cout << "------------" << std::endl;
    std::cout<<strvec;
    std::cout << "------------" << std::endl;
    strvec.emplace_back("其实emeplace通过参数包转发给std::string的构造");
    strvec.emplace_back(10,'c');
    std::cout<<strvec;

    return 0;
}