STL在c++中的地位想必不用赘述,想比于C语言,当你第一次接触c++的时候,你会惊叹于它的方便与便捷,真的是,应了那句话:"腰也不疼了,腿也不酸了,刷题也不头疼了,整个人都自信起来了".言归正传,今天我们来一步一步实现这个为我们提供方便的STL中的string类(友情提示:很全,比我网上找到的大部分都全),虽然比较全,却一点也不麻烦,有含金量的就那么几个函数,其他大部分都是重载,所以小伙伴不妨往下看一看吧.
目录
详细步骤
1.设置自己的命名空间:
为什么要设置自己的命名空间呢,很简单,人家自己有string类,那我们要想玩,就得关起门,我们自己造我们自己的,不和他们一起玩,当然,你也可以不叫string,也行,那没有和人家同名,就不需要这一步了,我的建议是加上,一方面显得专业,另一方面美观,编程也是一门艺术嘛,是吧
我制造的命名空间
namespace czz {}之后的自己的string类就放在大括号里面就行了
2.设置类名:
这个不用多说,string类也不是模板类,所以class就行了,之后的那些变量和函数,专业一点叫做属性和方法就放在里面的大括号里面就行了
namespace czz {
class string {
}
}3.设置权限:
就是有些东西大家一起分享,有些东西只能我自己知道,比如女孩子的年龄...
权限设置也很简单,一般而言,就三种,private(私有);public(公共);protected(保护),保护我们今天用不到,只说private和public,这两个很简单,一个是外面也能看的,一个是外面不能看的,举个栗子
class example {
public:
void my_cout() {
cout << a << endl;
}
private:
int a;
};
int main() {
example s;
s.a;
s.my_cout();
return 0;
}这是一段很简单的代码,你可以在自己的编译器上面写一下,到时候会报错,我用的是VS2022,错误是这样的:
就是说a是私有的,外面看不了,但是s.my_cout()却可以,就是因为它是公共的.
4.this指针
这个知识点原本是基础,但是害怕看这篇博客的有些同学不会,还是讲一下吧,就是你写成员函数的时候,编译器会自动给你多传一个参数,就是这个this指针,这个指针指向的是你调用这个函数的对象的地址.比如说我s.my_cout(),里面我打印的内容只有一个a,那万一我又创建了一个s2,也调用这个函数方法,那编译器怎么知道是哪个里面的a呢,就是靠的this指针,谁调用,就指向谁,到时候只写一个a,那就是本身这个对象的a
5.私有的四个属性变量
private:
char* _str;
size_t _size;
size_t _capacity;
static size_t npos;
};
size_t string::npos = -1;我们只关注前三个,最后一个想了解的自己去搜一下static的用法就明白了,这个变量代表着一个不可能的下标值,后main要是有,不想搜的改成-1就行了.第一个就是一个字符串,第二个代表这个字符串的有效长度,第三个是存储这个字符串的空间的大小,因为我们的字符串到时候需要new出来,所以并不是所有空间都是有效空间,需要有标注,后面的就都是公共的方法函数了
6.传统的构造析构等函数
如果对构造,拷贝构造,析构函数,赋值运算符重载没有了解的,建议去了解一下,不然下面的代码你会不知道是干嘛
构造函数
string(const char* s = "") {
if (s == nullptr) {
s = "";
}
_size = strlen(s);
_str = new char[strlen(s) + 1];
strcpy(_str, s);
_capacity = _size;
}拷贝构造函数
string(const string& s)
:_str(new char[strlen(s._str) + 1]) {
strcpy(_str, s._str);
_size = strlen(_str);
_capacity = _size;
}赋值运算符重载
//赋值运算符重载 之所以和拷贝构造函数不一样,是因为它之前可能有值,万一开辟空间失败了,原来的值还在
string& operator=(const string& s) {
if (this != &s) {
char* temp = new char[strlen(s._str) + 1];
strcpy(temp, s._str);
delete[] _str;
_str = temp;
_size = strlen(_str);
_capacity = _size;
}
return *this;
}析构函数
~string()
{
if (_str)
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
}7.现代版构造析构函数
上面的我相信大家都能看懂,底下的可就有一些难度了
构造函数
string(const char* s = "") {
if (s == nullptr) {
s = "";
}
_size = strlen(s);
_str = new char[strlen(s) + 1];
strcpy(_str, s);
_capacity = _size;
}
string(size_t n, char ch) {
_str = new char[n + 1];
memset(_str, ch, n);
_str[n] = '\0';
_size = n;
_capacity = n;
}这个还是比较简单的
拷贝构造函数
string(const string& s)
:_str(nullptr) {
string temp(s._str);
swap(temp);
}这个代码的意思是说,先用构造函数创建一个临时的对象,然后把这个临时对象的内容和本对象的内容交换,交换函数我们会在后面实现,然后这个对象本身的_str是nullptr,所以最后哪怕不调用析构也不会造成内存泄漏,当然,最后还是会自动调用的,不用我们操心
赋值运算符重载
string& operator=(const string& s) {
if (this != &s) {
string temp(s._str);
swap(temp);
}
return *this;析构函数
~string() {
if (_str) {
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
}8.迭代器
typedef char* iterator;
iterator begin() {
return _str;
}
iterator end() {
return _str + _size;
}9.修改
append(追加函数)
void append(size_t n, char ch) {
if (_size + n > _capacity) {
reserve(n + _size);
}
memset(_str + _size, ch, n);
_size = _size + n;
_str[_size] = '\0';
if (_capacity < _size) {
_capacity = _size;
}
}
void append(const char* str) {
size_t n = strlen(str);
if (_size + n > _capacity) {
reserve(n + _size);
}
strcat(_str, str);
_size = _size + n;
_capacity = _size;
}两种追加办法,一种是追加好多个一样的字符,一个是追加一个字符串
尾插
void push_back(char ch) {
append(1, ch);
}是不是很有效率呢
(有点丑)
+=运算符重载
string& operator+=(char ch) {
append(1, ch);
return *this;
}
string& operator+=(const char* str) {
append(str);
return *this;
}又复用了append
clear(清空函数)
void clear() {
_str[0] = '\0';
_size = 0;
}swap(交换函数)
void swap(string& s) {
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}变成C语言里面的 const char* 函数
const char* c_str()const {
return _str;
}10.容量相关的函数
获取有效长度的函数
size_t size()const {
return _size;
}
获取容量
size_t capacity()const {
return _capacity;
}判空函数
bool empty()const {
return _size == 0;
}resize(扩大有效元素个数)
void resize(size_t n, char c = '\0') {
if (n < _size) {
_str[n] = '\0';
}
if (n + _size > _capacity) {
reserve(n + _size);
}
append(n - _size, c);
}reserve(扩容)
void reserve(size_t n) {
if (n > _capacity) {
char* temp = new char[n + 1];
strcpy(temp, _str);
delete[] _str;
_str = temp;
_capacity = n;
}
}11.元素访问相关的函数
取下标
char& operator[](size_t index) {
assert(index < _size);
return _str[index];
}
const char& operator[](size_t index)const {
assert(index < _size);
return _str[index];
}12.插入删除函数
insert(插入函数)
string& insert(size_t pos, char c) { //在pos位置插入一个元素
if (_size == _capacity) {
reserve(_capacity * 2 + 3);
}
for (size_t i = _size; i > pos; i--) {
_str[i] = _str[i - 1];
}
_size++;
_str[_size] = '\0';
_str[pos] = c;
return *this;
}
string& insert(size_t pos, const char* str) { //在pos位置插入一个字符串
size_t n = strlen(str);
if (_size + n > _capacity) {
reserve(_size + n);
}
for (size_t i = _size + n; i >= pos + n; i--) {
_str[i] = _str[i - n];
}
for (size_t i = pos; i < pos + n; i++) {
insert(i, str[i - pos]);
}
return *this;
}erase(删除函数)
// 删除pos位置上的元素，并返回该元素的下一个位置
string& erase(size_t pos, size_t len) {
for (size_t i = pos; i < _size - len; i++) {
_str[i] = _str[i + len];
}
_size -= len;
_str[_size] = '\0';
return *this;
}13.查找函数
find(查找)
// 返回c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const {
for (size_t i = pos; i < _size; i++) {
if (_str[i] == c) {
return i;
}
}
return npos;
}
// 返回子串s在string中第一次出现的位置
size_t find(const char* s, size_t pos = 0) const {
char* address = strstr(_str, s);
if (address) {
for (int i = 0; i < _size; i++) {
if (address == _str + i) {
return i;
}
}
}
return npos;
}14.一些简单的比较运算符重载
bool operator<(const string& s) {
int tem = strcmp(_str, s._str);
if (tem < 0) {
return true;
}
return false;
}
bool operator<=(const string& s) {
int tem = strcmp(_str, s._str);
if (tem <= 0) {
return true;
}
return false;
}
bool operator>(const string& s) {
int tem = strcmp(_str, s._str);
if (tem > 0) {
return true;
}
return false;
}
bool operator>=(const string& s) {
int tem = strcmp(_str, s._str);
if (tem >= 0) {
return true;
}
return false;
}
bool operator==(const string& s) {
int tem = strcmp(_str, s._str);
if (tem == 0) {
return true;
}
return false;
}
bool operator!=(const string& s) {
int tem = strcmp(_str, s._str);
if (tem != 0) {
return true;
}
return false;
}这些属实没有什么含金量,就放在一起了.
最后,有疑问可以发在评论区里面,喜欢的点个赞,感谢!!!
1229
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
