Strvec class mobile copy

StrVec It's right vector Imitation of .string Continuously store... In memory , When there is not enough memory , Request twice the memory space , And make use of string For transfer .

Who are the members

class StrVec
{
    
public:
    StrVec() : elements(nullptr), first_free(nullptr), cap(nullptr) {
    }
    StrVec(const StrVec&);
    StrVec(StrVec&& s)noexcept;
    StrVec& operator=(StrVec&& rhs);
    StrVec& operator=(const StrVec&);
    ~StrVec();
    void push_back(const string&);
    size_t size() const {
     return first_free - elements; }
    size_t capacity() const {
     return cap - elements; }
    string* begin() const {
     return elements; }
    string* end() const {
     return first_free; }

private:
    static allocator<string> alloc;
    string* elements;// Head pointer 
    string* first_free;// Using the trailing pointer of memory 
    string* cap;// Array trailing pointer 
    void free();    // Destroy elements and free memory 
    void reallocate();  // Get more memory and copy existing elements 
    // Used by the function to which the element is added 
    void chk_n_alloc();

    // Tool function , Copied constructor 、 Assignment operator 、 Destructors use 
    pair<string*, string*> alloc_n_copy(const string*, const string*);
};

Analyze one by one

Data member

1. Static members allocator： Responsible for applying for memory space .allocator Class is used to separate memory request from object initialization .STL Regular use allocator Class dynamically applies for memory .allocate Can be regarded as malloc Encapsulation , deallocate Can be regarded as free（ No new and delete）, construct Consider calling the constructor manually ,deallocate It can be seen as a manual call to the destructor . After the memory is allocated, it can be regarded as StrVec There is a dynamic array inside the class .

string* p = new string[10]; Actually, I did two jobs ： Apply for ten with the operating system string Size of memory space , Then perform default initialization on it —— That is, run the default constructor . and alloc.allocate(10) Just apply for memory space , There is no initialization process .

2. Three pointers .elements, first_free, cap First pointer in turn , Tail pointer , Pointer to the last position in memory space .

Copy control

1. Default structure ： All three pointers are set to null .
2. Copy structure ： Allocate memory space of equal size first , And then use it unitialize_copy Method completes initialization in one time .
3. Mobile construction ： Allocate memory space of equal size first , Then set the three pointers to rhs Value . Pay attention to rhs Assigned to a destructible state .
4. Copy operator ： Copy and copy to ensure exceptional security . The rest are the same as the copy structure .
5. Move copy operator overload ： Use the method of comparing and excluding self assignment first , The rest are the same as the mobile structure .
6. Destructor ： Release allocator Of memory space .

Tool function

1. free： It's actually a destructor .
2. alloc_n_copy： Function extraction of copy construction . Returns the first and last pointers .
3. chk_n_copy： Determine whether the memory space is larger .
4. reallocate: Call this function when more space is needed . Apply for memory space first , Call again string Mobile copy of , Not available here unintial_copy.

Code

#include <iostream>
#include <algorithm>
#include <utility>
#include <memory>
#include <string>
using namespace std;

class StrVec
{
    
public:
    StrVec() : elements(nullptr), first_free(nullptr), cap(nullptr) {
    }
    StrVec(const StrVec&);
    StrVec(StrVec&& s)noexcept;
    StrVec& operator=(StrVec&& rhs);
    StrVec& operator=(const StrVec&);
    ~StrVec();
    void push_back(const string&);
    size_t size() const {
     return first_free - elements; }
    size_t capacity() const {
     return cap - elements; }
    string* begin() const {
     return elements; }
    string* end() const {
     return first_free; }

private:
    static allocator<string> alloc;
    string* elements;// Head pointer 
    string* first_free;// Using the trailing pointer of memory 
    string* cap;// Array trailing pointer 
    void free();    // Destroy elements and free memory 
    void reallocate();  // Get more memory and copy existing elements 
    // Used by the function to which the element is added 
    void chk_n_alloc();

    // Tool function , Copied constructor 、 Assignment operator 、 Destructors use 
    pair<string*, string*> alloc_n_copy(const string*, const string*);
};
void StrVec::chk_n_alloc()
{
    
    if (size() == capacity())
        reallocate();
}
void StrVec::push_back(const string& s)
{
    
    chk_n_alloc();
    alloc.construct(first_free++, s);
}
pair<string*, string*> StrVec::alloc_n_copy(const string* b, const string* e)
{
    
    // Allocate space to hold elements in a given range 
    auto data = alloc.allocate(e - b);
    // Initialize and return a pair
    return {
     data, uninitialized_copy(b, e, data) };
}
void StrVec::free()
{
    
    if (elements)
    {
    
        for_each(elements, first_free, [this](string* rhs) {
     this->alloc.destroy(rhs); });
        // for (auto p = first_free; p != elements; )
        // alloc.destroy(--p);
    }
    alloc.deallocate(elements, capacity());
}
StrVec::StrVec(const StrVec& s)
{
    
    auto newdata = alloc_n_copy(s.begin(), s.end());
    elements = newdata.first;
    first_free = cap = newdata.second;
}
StrVec::~StrVec()
{
    
    free();
}
StrVec& StrVec::operator=(const StrVec& rhs)
{
    
    auto data = alloc_n_copy(rhs.begin(), rhs.end());
    free();
    elements = data.first;
    cap = first_free = data.second;
    return *this;
}
void StrVec::reallocate()
{
    
    auto newcapacity = size() ? 2 * size() : 1;
    auto newdata = alloc.allocate(newcapacity);

    auto dest = newdata;
    auto elem = elements;
    for (size_t i = 0; i != size(); i++)
    {
    
        alloc.construct(dest++, move(*elements++));
    }
    free();

    elements = newdata;
    first_free = dest;
    cap = elements + newcapacity;

}
StrVec::StrVec(StrVec&& s)noexcept
    :elements(s.elements), first_free(s.first_free), cap(s.cap)
{
    
    s.cap = s.first_free = s.elements = nullptr;
}
StrVec& StrVec::operator=(StrVec&& rhs)
{
    
    if (this != &rhs)
    {
    
        free();
        elements = rhs.elements;
        cap = rhs.cap;
        first_free = rhs.first_free;
        rhs.first_free = rhs.elements = rhs.cap = nullptr;
    }
    return *this;
}
int main()
{
    
}