文章目录
- 一.string是什么
- 二.string的基本API
- 三、（简易版）string的基本实现
一.string是什么
通俗的来讲string说就是一个封装好了的字符串类定义在<string>中
string和c风格字符串对比
.char*是一个指针，string是一个类
string封装了char*,管理这个字符串，对外提供了接口
二·string的基本API
//构造函数
string();//创建一个空的字符串 例如: string str;
string(conststring& str);//使用一个string对象初始化另一个string对象
string(constchar* s);//使用字符串s初始化
string(int n, char c);//使用n个字符c初始化
//string基本赋值操作
string&operator=(constchar* s);//char*类型字符串 赋值给当前的字符串
string&operator=(conststring&s);//把字符串s赋给当前的字符串
string&operator=(char c);//字符赋值给当前的字符串
string& assign(constchar *s);//把字符串s赋给当前的字符串
string& assign(constchar *s, int n);//把字符串s的前n个字符赋给当前的字符串
string& assign(conststring&s);//把字符串s赋给当前字符串
string& assign(int n, char c);//用n个字符c赋给当前字符串
string& assign(conststring&s, int start, int n);//将s从start开始n个字符赋值给字符串,如s=hello,那么n=3,start=1，那么是hel中从e开始赋值3-1个字符
//string存取字符操作
char&operator[](int n);//通过[]方式取字符
char& at(int n);//通过at方法获取字符
//string的拼接操作
string&operator+=(conststring& str);//重载+=操作符
string&operator+=(constchar* str);//重载+=操作符
string&operator+=(constchar c);//重载+=操作符
string& append(constchar *s);//把字符串s连接到当前字符串结尾
string& append(constchar *s, int n);//把字符串s的前n个字符连接到当前字符串结尾
string& append(conststring&s);//同operator+=()
string& append(conststring&s, int pos, int n);//把字符串s中从pos开始的n个字符连接到当前字符串结尾
string& append(int n, char c);//在当前字符串结尾添加n个字符c
//string的查找和替换
3.1.2.5 string查找和替换
int find(conststring& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
int find(constchar* s, int pos = 0) const; //查找s第一次出现位置,从pos开始查找
int find(constchar* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
int find(constchar c, int pos = 0) const; //查找字符c第一次出现位置
int rfind(conststring& str, int pos = npos) const;//查找str最后一次位置,从pos开始查找
int rfind(constchar* s, int pos = npos) const;//查找s最后一次出现位置,从pos开始查找
int rfind(constchar* s, int pos, int n) const;//从pos查找s的前n个字符最后一次位置
int rfind(constchar c, int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, conststring& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n, constchar* s); //替换从pos开始的n个字符为字符串s
//string的子串
string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串
//string的插入和删除
string& insert(int pos, constchar* s); //插入字符串
string& insert(int pos, conststring& str); //插入字符串
string& insert(int pos, int n, char c);//在指定位置插入n个字符c
string& erase(int pos, int n = npos);//删除从Pos开始的n个字符
//string和c_style字符串转换
//string 转 char*
string str = "itcast";
constchar* cstr = str.c_str();
//char* 转 string
char* s = "itcast";
string sstr(s);
stringAPI演示
#include<iostream>
#include<string>
using namespace std;
void text01()
{
string s1;//默认构造
string s2("hello");
cout << s1 << endl;//s1结果
cout<< s2 << endl;//s2结果
s1 += "word";//可以看到string支持加等操作可以直接加上字符串
cout << s1;//因为string重载了【】所以可以向数组一样去使用他
cout << endl;
}
//常见的构造和+=赋值
三.string的基本和实现（简易版）
1.简单实现string
我们先实现一个简单的string，要考虑深浅拷贝问题，那么什么是深浅拷贝呢？
浅拷贝：就是指简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作；
大家可以参考这个代码这就是典型的深浅拷贝问题
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{ /*默认构造函数*/
cout << "Person默认构造桉树的调用" << endl;
}
Person(int age, int height)
{ /*有参构造函数*/
m_age = age;
m_height = new int(height); //在堆区开辟内存
cout << "Person有参构造函数的调用" << endl;
}
~Person()
{
if (m_height != NULL) {
delete m_height;
m_height = NULL;
}
cout << "Person析构函数的调用" << endl;
}
int m_age; //年龄
int* m_height; //体重
};
void test01(void)
{
Person p1(18, 160);
cout << "p1的年龄是" << p1.m_age << "体重是" << *p1.m_height << endl;
Person p2(p1);
cout << "p2的年龄是" << p2.m_age << "体重是" << *p2.m_height << endl;
}
int main(void)
{
test01();
system("pause");
return 0;
}
运行这段代码可以发现程序崩溃了，为什么呢？
原因竟是两个指针指向了同一块地址析构了两次，所以程序崩溃了
大家注意看这个箭头的地址是不是一样呢
好了解决我们深浅拷贝的问题就可以来进行模拟实现了
三.模拟实现
先不考虑增删查改，先搭个架子出来
namespace zdc
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;//这两个是迭代器，string的迭代器是原生指针
iterator begin()
{
return _str;//返回刚开始的指针
}
iterator end()
{
return _str + _size;//实际大小加开头指针就是end的地址
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;//提供的const的迭代器
}
/*string()
:_str(new char[1])//为什么举例这个呢其实好多人就是这样初始化的
//这样有问题的 可能以为顺序问题崩溃
, _size(0)
, _capacity(0)
{
_str[0] = '\0';
}*/
string(const char* str = "")//这个是给\0开辟的
{
_size = strlen(str);//只求一次strlen减少了复杂度的开销
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);//旧空间拷给新空间
}
// 传统写法 拷贝构造
// s2(s1)
//string(const string& s)
// :_str(new char[s._capacity+1])
// , _size(s._size)
// , _capacity(s._capacity)
//{
// strcpy(_str, s._str);
//}
// 现代写法 -- 资本主义/老板思维
// s2(s1)
void swap(string& tmp)//用tmp来构造str
{
::swap(_str, tmp._str);
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);//现代写法就比较巧妙了
//先写个交换的函数注意：：是为了区别库里面的函数
}
// s2(s1)
string(const string& s)//现代写法要过滤一些其他的东西最好初始化列表一下
:_str(nullptr)
, _size(0)
, _capacity(0)
{
string tmp(s._str);
swap(tmp); //this->swap(tmp);
}
// s顶替tmp做打工人
string& operator=(string s)//像这种=可以直接复用了
{
swap(s);
return *this;
}
~string()//析构函数
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
const char* c_str() const
{
return _str;//返回c风格的字符串
}
size_t size() const
{
return _size;//返回size
}
size_t capacity() const
{
return _capacity;//返回capicaty
}
const char& operator[](size_t pos) const
{
assert(pos < _size);//string可以向数组一样使用就是因为重载了【】
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n+1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
// 满了就扩容
/*if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;//这是以前老的写法如果有inset可以直接复用
++_size;
_str[_size] = '\0';*/
insert(_size, ch);
}
void append(const char* str)
{
//size_t len = strlen(str);
满了就扩容
_size + len 8 18 10
//if (_size + len > _capacity)
//{
// reserve(_size+len);
//}
//strcpy(_str + _size, str);
strcat(_str, str); 需要找\0，效率低
//_size += len;
insert(_size, str);
}
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
// 满了就扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
}
private:
size_t _capacity;//实际
size_t _size;//大小
char* _str;//指向开始的数据
}
4230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
