文章目录
一、STL
STL(standard template library 标准模板库)，是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。STL有许多版本，如惠普实验室完成的原始版本、P.J.版本、RW版本、以及后面我们主要学习参考的SGI版本。
STL有六大组件：仿函数、算法、迭代器、空间配置器、容器、配置器。
其中，容器包括string、vector、list、map等等，我们今天就先来学习string。
二、string类介绍
1. string类
C语言中，字符串是以’\0’结尾的一些字符的集合，为了方便操作，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的
，不太符合我们C++的特性，而且底层空间需要用户自己管理，稍不留神还可能会越界访问。所以，C++标准库中（STL）提供了string类，在使用string时，必须#include<string>以及using namespace std;。string类中有一百多个接口，但我们只要学习掌握一部分就好了，其余在需要时查阅就好。
2. auto、范围for
我们先介绍两个C++11中的语法，方便后面的学习
2.1 auto
在早期的C/C++中，用关键字auto修饰的变量，是具有自动存储器的局部变量。C++11中，auto有了全新的含义：auto是一个新的类型指示符，auto声明的变量必须由编译器在编译期间推导而得。
auto a = 1; //编译器推导得a的类型为int
auto b = 1.1; //编译器推导得b的类型为double
auto c = 1.1F; //后加F或f，编译器推导得c的类型为float
auto d = 'a'; //编译器推导得d的类型为char
auto e; //编译报错，编译器无法推导出e的类型
当auto声明指针类型时，用auto和auto*没有任何区别。但声明引用类型时，auto后必须加&。
当用auto在一行内声明多个变量时，这些变量的类型必须相同，否则编译器会报错。因为实际上编译器只会对第一个变量推导类型，然后用推导出的类型定义其他变量。如auto a = 1, b = 'x';是错误的写法。
除此之外，auto不能作为函数的参数，可以做返回值，但是不建议过多使用，因为可能会造成后续我们自己阅读判断类型的困难。
auto也不能直接声明数组，auto arr[] = {1, 2, 3}是错误的。
2.2 范围for
对于一个有范围的集合而言，由程序员来说明循环的范围略显多余，而且还可能犯错误。因此C++11中引入了基于范围的for循环，这种for循环后的括号由冒号分为两部分：范围内用于迭代的变量、被迭代的范围。程序会自动迭代，自动读取数据、自动判断结束。范围for可以作用带数组和容器对象上进行遍历。它的底层实际上是替换为迭代器。
int arr[] = { 1,2,3,4,5 };
//C/C++11以前的遍历：
for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
{
cout << arr[i];
}
cout << endl;
//C++11的遍历可以这样写：
for (auto e : arr)
{
//e会自动遍历arr的每一个元素
cout << e;
}
三、string类的常用接口
1. 构造与拷贝构造相关
string类对象的底层仍是一个字符数组，在构造时会自动在对象的结尾加上\0。
在文档https://legacy.cplusplus.com/reference/string/string/string/中我们能查到string类关中于构造和拷贝构造的成员函数有这些，其中
我框住的就需要我们重点学习，学会了这几个，其他函数就也能理解了。
string()：默认构造函数，构造出一个空的string类对象，即空字符串
string(const string& str)：拷贝构造函数
string (const string& str, size_t pos, size_t len = npos)：构造str的子字符串，参数的pos是子字符串开始的位置（下标），len是子字符串的字符个数（当len超过了str下面的长度，会自动读取到str结尾为止。同时这个参数还有缺省值npos，实际上是-1，size_t类型的最大值，npos代表我们不给len传参时也会自动读取到str结尾为止，下同）
string(const char* s)：用C语言的字符串（字符数组）来拷贝出string类对象
string (size_t n, char c)：构造一个string对象，其包含n个字符c
这些构造和拷贝构造相关的函数包含了我们常用的各种构造string类对象的方法，极大便利了我们的实际使用。简单测试看看：
2. 容量相关
以下是string中与容量相关的操作。同样地，框柱的是重点学习，其余自行就能理解。
string类，应该说它是一个存放字符的顺序表。它也有空间容量和字符串长度（字符个数）的成员变量，同时也有一些其他操作
- size：函数原型为
size_t size() const，返回string类对象的字符个数。string中有size和length两个变量，都代表着这个对象的长度，意义完全相同，我们为了和其他容器类型接口保持一致，一般常用size。size不会计算字符串结尾的\0，但会计算空格字符。
简单测试：
- resize：调整字符串大小，或以其他字符填充。resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用\0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。具体如下：
简单测试：
注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，则底层空间总大小不变。
-
reserve：修改字符串空间。虽说看起来reserve既可以扩容也可以缩容，但是不同的编译器关于reserve缩容行为都不一样，有可能会缩空间有也可能不缩，所以我们只建议用reserve来扩容。
-
clear：清空字符串
-
empty：判断字符串是否为空
3. 对象的访问
- operator[]：string类中重载了运算符[]，让我们可以直接像数组一样利用下标完成string类对象字符串的元素访问。
简单测试：
- begin、end：返回字符串的第一个字符、最后一个字符的迭代器。迭代器(iterator)我们可以先理解是一种类似于指针的东西，以后我们会进一步学习。
简单测试：
4. string对象的增删查改等
-
push_back：在字符串后尾插一个字符
简单测试：
-
append：在字符串后追加一个字符串，也是有很多的函数重载
简单演示：
-
operator+=：重载运算符+=，在字符串后追加字符串或字符
简单演示：
-
insert：字符串中插入，有很多函数重载应对不同场景
简单演示：
-
erase：删除字符串的一部分
简单测试：
-
find：在字符串查找字符或字符串第一次出现的位置，可以额外指定位置开始向后找，返回找到的下标，找不到则返回npos（-1）
简单测试：
-
rfind：在字符串查找字符或字符串最后一次出现的位置，可以指定位置开始向前找，返回找到的下标，找不到则返回npos（-1）
简单测试：
-
substr：在字符串中从pos位置开始，截取后面len个字符（或不传参默认截取到结束），然后返回
简单测试：
5. string类非成员函数
-
operator>>、operator<<：流插入、流提取操作符的重载，简单了解
-
getline：我们在向一个string类对象输入内容时，若用>>流提取运算符重载，则遇到空格字符时就会自动读取结束，即使这个空格也是我们想要的字符串的一部分。所以string中引入了getline函数，遇到空格不会停止读取，默认遇到换行符\n才停止读取，也可以自定义结束标识符。
简单演示：
-
关系判断运算符重载：简单了解，string类对象的大小比较和C语言中strcmp函数的道理类似
四、string模拟实现
自己实现一个string类，可以在一个命名空间内完成：
string.h中：
#pragma once
#include<iostream>
#include<string.h>
#include<assert.h>
namespace lydly
{
class string
{
public:
//定义常量npos
static const size_t npos;
//拷贝构造函数
string(const char* str = "") //默认会在结尾加\0
:_size(strlen(str))
{
_capacity = _size;
_str = new char[_size + 1]; //+1是为了给结尾的\0留位置
memcpy(_str, str, _size + 1);
//不能使用strcpy，如果str中间有\0字符就会中间停止拷贝
}
//析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
const char* c_str() const
{
return _str;
}
//以下函数具体实现在string.cpp中
//迭代器
typedef char* iterator;
typedef const char* const_iterator;
iterator begin();
iterator end();
const_iterator begin() const;
const_iterator end() const;
size_t size() const;
size_t capacity() const;
char& operator[](size_t i);
const char& operator[](size_t i) const;
void reserve(size_t n);
void push_back(char ch);
void append(const char* str);
string& operator+=(char ch);
string& operator+=(const char* str);
void insert(size_t pos, char ch);
void insert(size_t pos, const char* str);
void erase(size_t pos, size_t len = npos);
size_t find(char ch, size_t pos = 0) const;
size_t find(const char* str, size_t pos = 0) const;
string substr(size_t pos = 0, size_t len = npos) const;
bool operator<(const string& s) const;
bool operator<=(const string& s) const;
bool operator>(const string& s) const;
bool operator>=(const string& s) const;
bool operator==(const string& s) const;
bool operator!=(const string& s) const;
void clear();
void swap(string& s);
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
};
std::ostream& operator<<(std::ostream& os, const string& s);
std::istream& operator>>(std::istream& is, string& s);
}
string.cpp中：
#include"string.h"
namespace lydly
{
const size_t string::npos = -1;
string::iterator string::begin()
{
return _str;
}
string::iterator string::end()
{
return _str + _size;
}
string::const_iterator string::begin() const
{
return _str;
}
string::const_iterator string::end() const
{
return _str + _size;
}
size_t string::size() const
{
return _size;
}
size_t string::capacity() const
{
return _capacity;
}
char& string::operator[](size_t i)
{
assert(i < _size);
return _str[i];
}
const char& string::operator[](size_t i) const
{
assert(i < _size);
return _str[i];
}
void string::reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
if (_str)
{
memcpy(tmp, _str, _size + 1);
delete[] _str;
}
_str = tmp;
_capacity = n;
}
}
void string::push_back(char ch)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
_str[_size++] = ch;
_str[_size] = '\0';
}
void string::append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
size_t newcapacity = _size + len > 2 * _capacity ? _size + len : 2 * _capacity;
reserve(newcapacity);
}
memcpy(_str + _size, str, len + 1);
_size += len;
}
string& string::operator+=(char ch)
{
push_back(ch);
return *this;
}
string& string::operator+=(const char* str)
{
append(str);
return *this;
}
void string::insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
end--;
}
_str[pos] = ch;
_size++;
}
void string::insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (_size + len > _capacity)
{
size_t newcapacity = _size + len > 2 * _capacity ? _size + len : 2 * _capacity;
reserve(newcapacity);
}
size_t end = _size + len;
while (end > pos + len - 1)
{
_str[end] = _str[end - len];
end--;
}
for (size_t i = 0; i < len; i++)
{
_str[pos + i] = str[i];
}
_size++;
}
void string::erase(size_t pos, size_t len)
{
assert(pos < _size);
if (len == npos || len >= _size - pos)
{
//后面的全删
_str[pos] = '\0';
_size = pos;
}
else
{
memmove(_str + pos, _str + pos + len, _size + 1 - (pos + len));
_size -= len;
}
}
size_t string::find(char ch, size_t pos) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
return i;
}
return npos;
}
size_t string::find(const char* str, size_t pos) const
{
assert(pos < _size);
const char* p = strstr(_str, str);
if (p == nullptr)
{
return npos;
}
else
{
return p - _str;
}
}
string string::substr(size_t pos, size_t len) const
{
assert(pos < _size);
if (len > _size - pos)
{
len = _size - pos;
}
string ret;
ret.reserve(len);
for (size_t i = 0; i < len; i++)
{
ret += _str[pos + i];
}
return ret;
}
bool string::operator<(const string& s) const
{
size_t len1 = _size;
size_t len2 = s._size;
size_t i1 = 0, i2 = 0;
while (i1 < len1 && i2 < len2)
{
if (_str[i1] < s._str[i2])
{
return true;
}
else if (_str[i1] > s._str[i2])
{
return false;
}
else
{
i1++;
i2++;
}
}
return i1 == len1 && i2 < len2;
}
bool string::operator<=(const string& s) const
{
return *this < s || *this == s;
}
bool string::operator>(const string& s) const
{
return !(*this <= s);
}
bool string::operator>=(const string& s) const
{
return !(*this < s);
}
bool string::operator==(const string& s) const
{
size_t len1 = _size;
size_t len2 = s._size;
size_t i1 = 0, i2 = 0;
while (i1 < len1 && i2 < len2)
{
if (_str[i1] != s._str[i2])
{
return false;
}
else
{
i1++;
i2++;
}
}
return i1 == len1 && i2 == len2;
}
bool string::operator!=(const string& s) const
{
return !(*this == s);
}
void string::clear()
{
_str[0] = '\0';
_size = 0;
}
void string::swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
std::ostream& operator<<(std::ostream& os, const string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
os << s[i];
}
return os;
}
std::istream& operator>>(std::istream& is, string& s)
{
s.clear();
char buff[256];
size_t i = 0;
char ch = is.get();
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
ch = is.get();
if (i == 255)
{
buff[i] = '\0';
s += buff;
i = 0;
}
}
if (i > 0)
{
buff[i] = '\0';
s += buff;
}
return is;
}
}
本篇完，感谢阅读。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
