C++primer学习:拷贝控制(6):编写简化的string类

利用allocator类编写自己的string类,实现的功能有:

(1)拷贝构造函数和普通构造函数,接受c字符串风格的参数

(2)重载了运算符,实现=,和+(拼接字符串)

(3)实现了4种查找函数,可以定义查找的起始位置(或者不定义),查找第一个出现的满足条件的字符或者第一个不满足的字符.

(4)定义了相应的析构函数,和一些成员接口

(5)定义了提取子字符串的函数substr

#include "iostream"
#include "memory"
#include "utility"
#include "map"
#include "set"
#include "functional"
#include "vector"
#include "algorithm"
using namespace std;
class Str
{
public:
Str() :elements(nullptr), first_free(nullptr), cap(nullptr){}//默认构造函数
Str(const char * c);//接受字符串风格的参数
Str(const Str&);//拷贝构造函数
Str& operator= (const Str&);//拷贝赋值符号
~Str(){ free();}//析构函数
Str operator+(const Str&);//重载+运算符
Str substr(size_t pos, size_t len);//获取子字符串
Str substr(size_t pos){ return substr(pos,size());}//获取子字符串的重载形式
/*****************************查找成员**********************************/

char * find(const char ch){ find(0, ch); } //查找给定字符, 返回第一个字符所在的迭代器, 如果不存在, 返回尾后迭代器
char * find(size_t pos,const char ch); //从指定位置查找给定字符, 返回第一个字符所在的迭代器, 如果不存在, 返回尾后迭代器
char *find_not(const char ch){ find(0, ch); }//查找第一个不是ch的字符,返回所在的迭代器
char *find_not(size_t pos,const char ch);//从指定位置查找第一个不是ch的字符,返回所在的迭代器
char* find_fst_of(const char* ch){ find_fst_of(ch); }//查找第一个属于ch的字符,返回迭代器
char* find_fst_of(size_t pos, const char* ch);//查找第一个属于ch的字符,返回迭代器

/* *******************************  */
void print(){ if (elements)cout << elements << endl; }//输出指向的字符串
size_t size()const{ return first_free - elements; }
size_t length()const { return size() - 1; }
size_t capcity()const{ return cap - elements; }
char * begin()const{ return elements; }
char * end()const{ return first_free; }

private:
static allocator<char> alloc;
pair<char*, char*>alloc_n_copy(const char*,const  char*);

void free();
char *elements;
char* first_free;
char *cap;
};
allocator<char> Str:: alloc;
/*********public:**********/

Str::Str(const char * c)
{
auto newdata = alloc_n_copy(c, c + strlen(c)+1);//+1是为了把\0保存
elements = newdata.first;
first_free =cap = newdata.second;
}
Str::Str(const Str& s)
{
auto newdata = alloc_n_copy(s.begin(), s.end());
elements = newdata.first;
first_free = cap = newdata.second;
}
Str& Str:: operator= (const Str& s)
{
auto newdata = alloc_n_copy(s.begin(), s.end());
free();//释放旧的内存空间
elements = newdata.first;
first_free = cap = newdata.second;
return *this;
}
Str Str::operator+(const Str& s)
{
auto data = alloc.allocate(s.size()+size()-1);//动态分配内存
auto temp_end = uninitialized_copy(begin(), end(), data);//将内存拷贝到新分配的位置
auto real_end = uninitialized_copy(s.begin(), s.end()+1, temp_end-1);//注意上一个的结尾是\0，需要覆盖
return Str(data);
}
Str Str::substr(size_t pos, size_t len)
{
auto beg = elements + pos;
beg = beg<first_free ? beg : first_free;//不能超过有效位置
auto end = elements + pos + len;
end = end < first_free ? end : first_free;//不能超过有效位置
if (beg == end)//如果起始位置和终止位置一致，返回空字符
return Str();
auto newdata = alloc_n_copy(beg,end);
return Str(newdata.first);
}
char * Str::find(size_t pos,const char ch)//查找给定字符,返回第一个字符所在的迭代器,如果不存在,返回尾后迭代器
{
auto beg = begin()+pos;
beg = beg<first_free ? beg : first_free;//不能超过有效位置
for (; beg != end() && *beg != ch; ++beg){}
return beg;
}
char * Str::find_not(size_t pos,const char ch)
{
auto beg = begin()+pos;
beg = beg<first_free ? beg : first_free;//不能超过有效位置
for (; beg != end() && *beg == ch; ++beg){}
return beg;
}
char* Str::find_fst_of(size_t pos, const char* ch)
{
auto beg = begin() + pos;
beg = beg<first_free ? beg : first_free;//不能超过有效位置
set<char> is_of(ch, ch + strlen(ch));
for (; beg != end() && is_of.find(*beg) == is_of.end(); ++beg){}//通过set查找
return beg;
}
/************* private: ******************/
pair<char*, char*>Str::alloc_n_copy(const char*b,const char*e)
{
auto data = alloc.allocate(e-b);//动态分配内存
return{ data, uninitialized_copy(b, e, data) };//将内存拷贝到新分配的位置
}
void Str::free()
{
if (!elements)//不接受elements为空的情况
return;
for_each(elements, first_free, [](const char s) { alloc.destroy(&s);});
alloc.deallocate(elements, capcity());
}
void free();

int main()
{

Str a("mmbsad");
auto re = a + "fff"+"bbb";
re.print();
cout<<re.find_fst_of(0, "b");
return 0;

}