目录
1、认识string类
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一系列字符串的库函数， 但是这些库函数与字符串是分离开的，不太符合面向对象的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
在OJ题中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。
2、标准库中的string类
string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，string其实并不属于STL，而是属于标准库。这个类独立于所使用的编码来处理字节，string 类可以存储多字节或变长字符序列，但在操作时是基于字节而非字符的。
2.1、string类的常见接口
只讲解最常用的接口，对其他的接口感兴趣的可以点击string类文件的介绍查看。
2.1.1、构造与赋值重载
cpp
string(); // 构造空的string类对象，即空字符串
string (const string& str); // 用string对象构造string对象
string (const char* s); // 用C式字符串构造string对象
string (size_t n, char c); // 用n个c构造string对象
string& operator= (const string& str); // 赋值重载
string& operator= (const char* s);
string& operator= (char c); 2.1.2、迭代器
cpp
// 正向迭代器
iterator begin(); // 返回第一个位置
iterator end(); // 返回第一个位置的下一个位置
const_iterator begin() const;
const_iterator end() const;
// 反向迭代器
reverse_iterator rbegin(); // 返回最后一个位置
reverse_iterator rend(); // 返回最后一个位置的上一个位置
const_reverse_iterator rbegin() const;
const_reverse_iterator rend() const; 注：关于迭代器的原理，可以看看下面的string的模拟实现。
例如：
cpp
int main()
{
string s1;
string::iterator t1 = s1.begin();
while (t1 != s1.end())
{
cout << *t1;
++t1;
}
cout << endl;
string s2("hello world");
string::iterator t2 = s2.begin();
while (t2 != s2.end())
{
cout << *t2;
++t2;
}
cout << endl;
string s3(s2);
string::iterator t3 = s3.begin();
while (t3 != s3.end())
{
cout << *t3;
++t3;
}
cout << endl;
string s4(10, 'a');
string::iterator t4 = s4.begin();
while (t4 != s4.end())
{
cout << *t4;
*t4 += 1;
++t4;
}
cout << endl;
const string s5(s2);
string::const_reverse_iterator t5 = s5.rbegin();
while (t5 != s5.rend())
{
cout << *t5;
++t5;
}
cout << endl;
string s6;
s6 = s4;
string::const_iterator t6 = s6.begin();
while (t6 != s6.end())
{
cout << *t6;
++t6;
}
cout << endl;
return 0;
}2.1.3、容量
cpp
size_t size() const; // 返回有效字符长度
size_t length() const; // 返回有效字符长度
void resize (size_t n); // 将有效字符的个数改为n个
void resize (size_t n, char c); // 将有效字符的个数改成n个，多出的空间用字符c填充
size_t capacity() const; // 返回空间的总大小
void reserve (size_t n = 0); // 预留空间
void clear(); // 清空字符串
bool empty() const; // 判断是否为空，是返回true，否返回false注意：
1、size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一 致，一般情况下基本都是用size()。
2、clear()只是将string中有效字符清空，不改变底层空间大小。
3、resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时，resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。
注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4、reserve(size_t n=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
例如：
cpp
int main()
{
string s1("hello world");
cout << s1.size() << endl;
cout << s1.length() << endl;
cout << s1.capacity() << endl;
s1.clear();
cout << s1.size() << endl;
cout << s1.length() << endl;
cout << s1.capacity() << endl;
cout << s1.empty() << endl;
s1 = "i am a student";
cout << s1.size() << endl;
cout << s1.length() << endl;
cout << s1.capacity() << endl;
s1.reserve(100);
cout << s1.size() << endl;
cout << s1.length() << endl;
cout << s1.capacity() << endl;
s1.resize(50, 'o');
cout << s1.size() << endl;
cout << s1.length() << endl;
cout << s1.capacity() << endl;
string::iterator t1 = s1.begin();
while (t1 != s1.end())
{
cout << *t1;
++t1;
}
cout << endl;
return 0;
}2.1.4、访问
cpp
char& operator[] (size_t pos); // 返回pos位置的字符
const char& operator[] (size_t pos) const;
char& back(); // 返回最后一个元素
const char& back() const;
char& front(); // 第一个元素
const char& front() const;
// 范围for例如：
cpp
int main()
{
string s1("i love you");
for (int i = 0; i < s1.size(); i++)
{
cout << s1[i];
}
cout << endl;
cout << s1.front() << endl;
cout << s1.back() << endl;
string s2("aaaaaaaaaaaa");
for (auto& e : s2) // 在底层实际上用的还是迭代器
{
cout << e;
e += 1;
}
cout << endl;
for (auto e : s2)
{
cout << e;
}
return 0;
}2.1.5、修改
cpp
string& operator+= (const string& str); // 追加字符串
string& operator+= (const char* s); // 重载
string& operator+= (char c); // 重载
string& append (const string& str); // 追加字符串
string& append (const char* s); // 重载
string& append (size_t n, char c) // 重载
void push_back (char c); // 尾插字符
string& insert (size_t pos, const char* s); // pos位置前插入字符串注意：在string尾部追加字符时，s.push_back(c)和s.append(1, c)以及s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
例如：
cpp
int main()
{
string s1("i am");
s1 += " student";
for (char s : s1)
{
cout << s;
}
cout << endl;
s1.push_back('!');
s1.append("do you like me?");
for (auto s : s1)
{
cout << s;
}
cout << endl;
s1.insert(13, " ");
for (auto s : s1)
{
cout << s;
}
return 0;
}2.1.6、字符串操作
cpp
const char* c_str() const; // 返回C式字符串
size_t find (const char* s, size_t pos = 0) const; // 从pos位置向后开始查找字符串
size_t find (char c, size_t pos = 0) const;
size_t rfind (const char* s, size_t pos = npos) const; // 从pos位置向前查找字符串
size_t rfind (char c, size_t pos = npos) const;
string substr (size_t pos = 0, size_t len = npos) const; // 从pos位置开始截len个长度的字符串构造对象例如：
cpp
int main()
{
string s1("i am");
const char* s2 = s1.c_str();
s1 += " student! do you like me?";
size_t n = s1.find("like me", 0);
string s3 = s1.substr(n, 7);
for (auto e : s3)
{
cout << e;
}
cout << endl;
return 0;
}2.1.7、成员常量
cpp
static const size_t npos = -1; // size_t类型的最大值2.1.8、非成员函数
cpp
string operator+ (const string& lhs, const string& rhs); // 运算符重载
istream& operator>> (istream& is, string& str); // 流提取
ostream& operator<< (ostream& os, const string& str); // 流插入
istream& getline (istream& is, string& str); // 获取一行字符串，默认遇换行结束
istream& getline (istream& is, string& str, char delim); // 可以指定遇到delim结束
bool operator== (const string& lhs, const string& rhs); // 等于
bool operator!= (const string& lhs, const string& rhs); // 不等于
bool operator< (const string& lhs, const string& rhs); // 小于
bool operator<= (const string& lhs, const string& rhs); // 小于等于
bool operator> (const string& lhs, const string& rhs); // 大于
bool operator>= (const string& lhs, const string& rhs); // 大于等于例如：
cpp
int main()
{
string s1("100");
s1 = s1 + "100";
cout << s1 << endl;
string s2;
getline(cin, s2);
cout << s2 << endl;
cout << (s1 == s2) << endl;
string s3;
cin >> s3;
cout << s3 << endl;
cout << string::npos << endl;
return 0;
}2.1.9、转换函数
cpp
int stoi (const string& str, size_t* idx = 0, int base = 10); // 转换为整数
string to_string (int val); // 转换为string类型例如：
cpp
int main()
{
string s1("100");
int n = stoi(s1);
n += 50;
string s2 = to_string(n);
for (auto e : s2)
{
cout << e;
}
cout << endl;
return 0;
}上面的几个接口了解一下，下面的OJ题目中会有一些体现他们的使用，此外还可以看string的模拟实现，来理解string类的使用。string类中还有一些其他的操作，这里不一一列举，大家在需要用到时不明白了查文档即可。
2.2、vs和g++下的string
注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。
2.2.1、vs下的string
string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字 符串的存储空间： 当字符串长度小于16时，使用内部固定的字符数组来存放当字符串长度大于等于16时，从堆上开辟空间。
2.2.2、g++下的string
G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指 针将来指向一块堆空间，内部包含了如下字段： 空间总大小、字符串有效长度、引用计数。
写时拷贝是写时再进行深拷贝，是通过"浅拷贝"和引用计数机制，以及"延迟复制"策略来实现的。当创建对象或赋值时，多个对象可以共享同一份数据（不立即复制），只有当其中某个对象需要修改这份共享数据时，才会为它创建一份独立的拷贝（即"写"操作触发复制）。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为0，说明该对象为资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
3、OJ题
3.1、仅仅反转字母
参考：
3.2、第一个出现一次的字符
参考：
3.3、最后一个单词的长度
参考：
注意：无论是scanf还是cin都有一个特点就是遇到空格或者换行就会结束。
3.4、字符串是否回文
参考：
3.5、字符串相加
参考：
上面的这个题时间复杂度比较高，我们可以进行优化一下：
4、模拟实现
我们只实现string类的主要的功能。
cpp
class String
{
public:
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////
//迭代器 这里的迭代器是用原生指针实现的。
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
// //////////////////////////////////////////////////////////////////////////////////////////////////////////////
//特殊的成员函数
/*String()
:_str(new char('\0'))
,_size(0)
,_capacity(0)
{}
String(const char* str)
:_size(strlen(str))
,_capacity(_size)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}*/
String(const char* str="") //上面的两个构造函数合并这一个构造函数。
:_size(strlen(str))
, _capacity(_size)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}
/*String(const String& s)//传统写法的构造函数
{
_str = new char[s.capacity()+1];
strcpy(_str, s._str);
_size = s.size();
_capacity = s.capacity();
}*/
void swap(String& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);//这个是算法库里面的函数。
}
String(const String& s)//现代写法的构造函数
/*:_str(nullptr) //不写这个在vs不报错，但是在其他编译器上不写这个可能会出现错误。一般情况下，编译器不会对自定义类型处理
, _size(0) //但在vs上，编译器把_str处理为nullptr,_size和_capacity处理为0。不处理的情况下，默认为随机值，等到出作用域销毁的
, _capacity(0)*/ //时候，也就是delete的时候就会出现错误。
{
String tmp(s._str);
swap(tmp);
}
~String()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
//String& operator=(const String& s)//传统写法
//{
// if (this != &s)
// {
// char* tmp= new char[s.capacity() + 1];
// strcpy(tmp, s._str);
// delete[] _str;
// _str = tmp;
// _size = s.size();
// _capacity = s.capacity();
// }
// return *this;
//}
//String& operator=(const String& s)//现代写法
//{
// if (this != &s)
// {
// String tmp(s);
// swap(tmp);
// }
// return *this;
//}
String& operator=(String s)//极致的现代写法
{
swap(s);
return *this;
}
// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//普通的成员函数
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const//为const对象提供的重载形式
{
assert(pos < _size);
return _str[pos];
}
const char* c_str() const
{
return _str;
}
void reserve(size_t n)
{
if (n>_capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void resize(size_t n, char c = '\0')
{
if (n <= _size)
{
_str[n] = '\0';
_size = n;
}
else
{
reserve(n);
while (_size < n)
{
_str[_size] = c;
++_size;
}
_str[_size] = '\0';
}
}
size_t find(char ch, size_t pos = 0)
{
for (size_t i = pos; i < _size; i++)
{
if (ch == _str[i])
{
return i;
}
}
return npos;
}
String substr(size_t pos, size_t len = npos)
{
String s;
size_t end = pos + len;
if (len == npos || len + pos >= _size)
{
len = _size - pos;
end = _size;
}
s.reserve(len);
for (size_t i = pos; i < end; i++)
{
s += _str[i];
}
return s;
}
size_t find(const char* sub, size_t pos = 0)
{
const char* tmp = strstr(_str + pos, sub);
if (tmp)
{
return tmp - _str;
}
else
return npos;
}
void push_back(const char ch)
{
if (_capacity == _size)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (len + _size > _capacity)
{
reserve(len + _size);
}
strcpy(_str + _size, str);
_size += len;
}
String& operator+=(char ch)
{
push_back(ch);
return *this;
}
String& operator+=(const char* str)
{
append(str);
return *this;
}
String& operator+=(const String& s)
{
append(s._str);
return *this;
}
void insert(size_t pos,char ch)
{
assert(pos <= _size);
if (_capacity == _size)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
size_t end = _size+1;
while (end > pos)
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = ch;
++_size;
}
void insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (len + _size > _capacity)
{
reserve(len + _size);
}
size_t end = _size+1;
while (end > pos)
{
_str[end+len-1] = _str[end-1];
--end;
}
strncpy(_str + pos, str, len);
_size += len;
}
void erase(size_t pos = 0, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len + pos > _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
size_t begin = pos + len;
while (begin <= _size)
{
_str[begin - len] = _str[begin];
++begin;
}
_size -= len;
}
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
/*size_t size()
{
return _size;
}
size_t capacity()
{
return _capacity;
}*/
size_t size() const//其实写了下面的两个const修饰的成员函数就没必要写上面的两个成员函数了。
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator==(const String& s) const
{
return strcmp(_str, s._str) == 0;
}
bool operator<(const String& s) const
{
return strcmp(_str, s._str) < 0;
}
bool operator>(const String& s) const
{
return !(*this <= s);
}
bool operator<=(const String& s) const
{
return *this == s || *this < s;
}
bool operator>=(const String& s) const
{
return !(*this < s);
}
bool operator!=(const String& s) const
{
return !(*this == s);
}
// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private:
char* _str;
size_t _size;
size_t _capacity;
public:
const static size_t npos;//为了在类外也能访问，所以公开了。
};
const size_t String::npos = -1;
// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*istream& operator>>(istream& in, String& s)
{
s.clear();
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}*/
istream& operator>>(istream& in, String& s)//上面的优化版本
{
s.clear();
char buff[129];
size_t i = 0;
char ch; //流提取默认遇到空格或者换行结束
//in >> ch; //这种写法是不行的，因为流提取没法提取空格或者换行。
ch = in.get();//这里的get函数是库里面的函数，这个函数是可以拿到空格和换行的。
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 128)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
ostream& operator<<(ostream& out, const String& s)
{
/*for (size_t i = 0; i < s.size(); i++)
{
out << s[i];
}*/
for (auto ch : s)//范围for也是可以的。
out << ch;
return out;
}5、补充
编码表：值和符号一一映射的关系。
ASCII表 被制作时仅仅考虑到了英文，为了让电脑能呈现其他国家的语言，所以就制作了Unicode统一码，也叫万国码。Unicode又可以分为UTF-8、UTF-16、UTF-32。UTF-8是兼容ASCII表的，对于常见的汉字，用UTF-8编码占两个字节，越是不常用的汉字占的字节数越多，但不超过4个字节。
GBK全称《汉字内码扩展规范》，之所以会有GBK的存在是因为有些生僻字或者古汉字用Unicode不能很好的兼容，因而制作出了更符合中国的GBK编码，使用了双字节的编码方案。
Windows上一般使用GBK，Linux上一般用UTF-8。
乱码一般是指存储方式和解释方式不同而导致的解析出的一些没有规律的字符或者数字等。