C++primer 练习13.39

13.39 编写你自己版本的StrVec，包括自己版本的reserve，capacity（参见9.4节，第318页）和resize（参见9.3.5节，第314页）

13.40 为你的StrVec类添加一个构造函数，它接受一个initializer_list<string>参数

这是StrVec.h

#pragma once

#include<string>
#include<memory>
#include<initializer_list>
using namespace std;

class StrVec
{
public:
StrVec():
elements(nullptr),first_free(nullptr),cap(nullptr){}
StrVec(initializer_list<string> iLStr);//构造函数，接受一个initializer_list<string>参数
StrVec(const StrVec&);
StrVec& operator=(const StrVec&);
~StrVec();
string& operator[](size_t n)const //重载下标运算符，用来实现TextQuery和QueryResult对StrVec的使用
{
return *(elements + n);
}
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; }
void reserve(size_t n);//分配至少容纳n个元素的空间
void resize(size_t n);//调整容器的大小为n个元素。若n<size()，则多出的元素被丢弃
//若必须添加新元素，对新元素进行值初始化
void resize(size_t n,string str);//调整容器的大小为n个元素，任何新添加的元素都初始化为值str
private:
allocator<string> alloc;
void chk_n_alloc()
{
if (size() == capacity())
reallocate();
}
pair<string*, string*>alloc_n_copy(const string *, const string *);
void free();
void reallocate();
string *elements;
string *first_free;
string *cap;
};

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)
{
auto data = alloc.allocate(e - b);
return{ data,uninitialized_copy(b,e,data) };
}

void StrVec::free()
{
if (elements) {
for (auto p = first_free;p != elements;)
alloc.destroy(--p);
alloc.deallocate(elements, cap - elements);
}
}

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;
first_free = cap = 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(*elem++));
free();
elements = newdata;
first_free = dest;
cap = elements + newcapacity;
}

void StrVec::reserve(size_t n)//分配至少容纳n个元素的空间
{
if (n > capacity())//如果n大于capacity（）才会从新分配空间
{
auto newdata = alloc.allocate(n);//重新分配n个空间，newdata为新分配的空间的首地址
auto dest = newdata;
auto elem = elements;
for (;elem != first_free;)       //为新分配的空间调用construct来实现string的构造，采用move调用的是移动构造函数
alloc.construct(dest++, move(*(elem++)));
free();                          //元素的移动完成，释放原有的空间
elements = newdata;              //为指针赋予新的值
first_free = dest;
cap = elements + n;
}
else return;
}

void StrVec::resize(size_t n)//调整容器的大小为n个元素。若n<size()，则多出的元素被丢弃
//若必须添加新元素，对新元素进行值初始化
{
if (n <= size())  //如果n<size()则，应该对n后面的所有已经构造的元素调用destroy（），即多出的元素被丢弃
{
for (;first_free != elements + n;)
alloc.destroy(--first_free);
}
else
{
if (n > capacity())
{
reserve(n);   //因为n>capacity()，所以一定会分配新的空间
}
for (;first_free != elements + n;)  //添加新的元素，对新的元素进行值初始化
alloc.construct(first_free++, string(""));
}
}

void StrVec::resize(size_t n,string str)//调整容器的大小为n个元素，任何新添加的元素都初始化为值str

{
if (n <= size())  //如果n<size()则，应该对n后面的所有已经构造的元素调用destroy（），即多出的元素被丢弃
{
for (;first_free != elements + n;)
alloc.destroy(--first_free);
}
else
{
if (n > capacity())
{
reserve(n);   //因为n>capacity()，所以一定会分配新的空间
}
for (;first_free != elements + n;)  //添加新的元素为str
alloc.construct(first_free++, str);
}
}

StrVec::StrVec(initializer_list<string> iLStr)//构造函数，接受一个initializer_list<string>参数
{
auto newdata = alloc_n_copy(std::begin(iLStr), std::end(iLStr));//调用alloc_n_copy函数，返回一个pair<string*,string*>
elements = newdata.first;                            //pair的第一个元素为新分配空间的地址
first_free = cap = newdata.second;                   //pair的第二个元素为新分配空间的最后一个元素之后的地址
}

下面是主函数，用来验证程序的正确性

// 13.5.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#define _SCL_SECURE_NO_WARNINGS
#include"StrVec.h"
#include<string>
#include<iostream>
#include<memory>
using namespace std;

int main()
{
StrVec sv({ "li","dandan","is" });
cout << sv.size() << " " << sv.capacity() << endl;
sv.resize(5, "handsome");
cout << sv.size() << " " << sv.capacity() << endl;
sv.resize(3);
cout << sv.size() << " " << sv.capacity() << endl;
sv.resize(6);
cout << sv.size() << " " << sv.capacity() << endl;
sv.reserve(20);
sv.push_back("handsome");
cout << sv.size() << " " << sv.capacity() << endl;
return 0;
}