c字符串类

string类

将StrVec类的一些变量进行全局替换就能得到线类

1、字符串替换为茶

2、字符串替换为c、可疑交易报告替换为c

3、服务器替换为线

4 、#包含字符串替换为# includecstring

StrVec和线就是类似的

1、都是保存指向元素的指针，指向的空间都是在内中动态分配的。

2、拷贝构造函数、拷贝赋值运算符拷贝字符串类的成员和指向的元素（拷贝赋值运算符有析构指向空间的过程)

3、析构函数都是析构指针指向的空间。

不同点：

重新分配：

StrVec:是移动原空间的数据到新空间，释放原空间的线对象，不释放线指向的茶元素（移动后原线指向的空间为nullptr)

String:移动茶后，不会释放茶

原因是StrVec有两层指向，最基础的一层是不能销毁的，否则移动到新空间的数据被销毁了（这个地方还理解不清楚)

字符串。h

#包含cstring

#包括内存

#包含实用工具//配对移动

#包含初始值设定项_列表//初始值设定项_列表

#包含算法//对于每一个

#ifndef STRVEC__H

#定义STRVEC__H

使用命名空间标准；

类别字符串{ 0

公众号：

String():b(nullptr)，e(nullptr)，cap(nullptr){}

字符串(const char *)；

字符串（常量字符串);

字符串(字符串)；

字符串运算符=(常量字符串);

字符串运算符=(字符串);

~ String()；

void push _ back(const char)；

size _ t size()const { return e-b；}

size _ t capacity()const { return cap-b；}

void reserve(const size _ t)；

void resize(const size _ t)；

void resize(const size_t，const char)；

char * begin()const { return b；}

char * end()const { return e；}

私人：

静态allocatorchar alloc

void chk _ n _ alloc(){ if(size()==capacity())recall()；}

pairchar*、char* alloc_n_copy(const char*、const char *)；

void free()；

void recall()；

char * b；

char * e；

char * cap

}

#endif

String.cpp

#包括"字符串。h "

//静态成员变量定义和默认初始化。

//静态成员变量不属于任何对象，不能在类的构造函数中被构造和初始化，必须在类的外部定义和初始化

//不要重复写静电

//静态函数可以在类内部定义（没有初始化一说)

alloctorchar字符串： alloc

字符串：字符串(常量初始值设定项_列表字符c){ 0

auto p=alloc_n_copy(c.begin()、c . end())；

b=p.first

e=cap=p秒；

}

字符串：字符串(常量字符* c){ 0

auto p=alloc_n_copy(c，c strlen(c))；

b=p.first

e=cap=p秒；

}

pairchar*，char * string : alloc _ n _ copy(const char * b _ ptr，const char * e _ ptr){ 0

自动p=alloc。分配(e _ ptr-b _ ptr)；

返回{p，未初始化的_copy(b_ptr，e_ptr，p)}；

}

void字符串： free(){ 0

如果(e){ 0

for(auto p=e；p！=b；)

alloc。销毁(-p)；

alloc。democrate(cap-b)；

}

}

void字符串： reca pile(){ 0

size _ t新容量=size()2 * size(): 1；

自动p=alloc。分配(新容量)；

自动dst=p；

auto src=b；

for(size _ t I=0；我！=size()；（一)

alloc.construct(dst，STD : move(* src))；

b=p；

e=dst//p size()；

cap=p新容量

}

字符串：字符串（常量字符串)

auto p=alloc_n_copy(s.begin()、s . end())；

b=p.first

e=cap=p秒；

}

String:String(字符串s):b(s.b)，e(s.e)，cap(s.cap) {//要修改s的内部成员，所以不能为常数

s。b=s . e=s . cap=nullptr

}

字符串：运算符=(常量字符串)

auto p=alloc_n_copy(s.begin()、s . end())；

free()；

b=p.first

e=cap=p秒；

}

字符串：3360运算符=(字符串){//要修改s的内部成员，所以不能为常数

如果（这个！=s){ 0

free()；

b=s.b

e=s.e

cap=s.cap

s。b=s . e=s . cap=nullptr

}

返回*这个；

}

字符串： ~字符串(){ 0

free()；

}

空字符串： push _ back(const char c){ 0

chk _ n _ alloc()；

alloc.construct(e，c)；

}

void字符串：调整大小(const size _ t n){ 0

if(n容量()){ 0

自动p=alloc。分配(n)；

自动dst=p；

auto src=b；

size _ t I=0；

for(；我！=size()；（一)

alloc.construct(dst，STD : move(src))；

for(；我！=n；（一)

alloc。施工(dst)；

free()；

b=p；

e=cap=dst

} else if(n size()){ 0

而（东b北)

alloc。建构(e)；

} else {

而（东b北)

alloc。销毁(-e)；

}

}

void字符串：调整大小(const size _ t n，const char c){ 0

if(n容量()){ 0

自动p=alloc。分配(n)；

自动dst=p；

auto src=b；

size _ t I=0；

for(；我！=size()；（一)

alloc.construct(dst，STD : move(src))；

for(；我！=n；（一)

alloc.construct(dst，c)；

free()；

b=p；

e=cap=dst

} else if(n size()){ 0

而（东b北)

alloc.construct(e，c)；

} else {

而（东b北)

alloc。销毁(-e)；

}

}

void字符串： RESERVE(const size _ t n){ 0

如果(容量)(n){ 0

自动p=alloc。分配(n)；

自动dst=p；

auto src=b；

for(size _ t I=0；isize()；（一)

alloc.const(dst，STD : move(src))；

free()；

b=p；

e=dst

cap=b n；

}

}

测试代码

字符串字符串(“你好”)；

适用于(const auto v : str)

coutv

coutendl