string类
1. string 是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同,再添加了一些专门用来操作 string 的常规操作。
3. string 在底层实际是: basic_string 模板类的别名, typedef basic_string<char, char_traits, allocator> string;
4. 不能操作多字节或者变长字符的序列。
在使用string类时,必须包含#include头文件以及using namespace std;
string类常用接口
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 res_arg=0) :为 string 预留空间,不改变有效元素个数,当 reserve 的参数小于
string 的底层空间总大小时, reserver 不会改变容量大小。
5. 在 string 尾部追加字符时, s.push_back(c) / s.append(1, c) / s += 'c' 三种的实现方式差不多,一般 情况下 string 类的 += 操作用的比较多, += 操作不仅可以连接单个字符,还可以连接字符串。
6. 对 string 操作时,如果能够大概预估到放多少字符,可以先通过 reserve 把空间预留好。
vector和字符串配合使用:
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;
class String
{
friend ostream& operator<<(ostream& cout, const String& s);
public:
String(const char* str)
{
this->m_data = new char[strlen(str) + 1];
strcpy(this->m_data, str);
}
String(const String& s)
{
this->m_data = new char[strlen(s.m_data) + 1];
strcpy(this->m_data, s.m_data);
}
String& operator=(const String& s)
{
if (this != &s)
{
delete[] this->m_data;
this->m_data = new char[strlen(s.m_data) + 1];
strcpy(this->m_data, s.m_data);
}
return *this;
}
~String()
{
delete[] this->m_data;
this->m_data = nullptr;
}
private:
char* m_data;
};
ostream& operator<<(ostream& cout, const String& s)
{
cout << s.m_data;
return cout;
}
void test1()
{
vector<char> v;
for (int i = 0; i < 10; ++i)
{
v.push_back('a' + i);
}
for (auto& e : v)
{
cout << e;
}
cout << endl;
}
void test02()
{
const char* str[] = { "abc","xyz","lmn" };
//vector<char*> v(str,str+3);
vector<const char*>v;
for (int i = 0; i < 3; ++i)
{
v.push_back(str[i]);
}
for (auto& e : v)
{
cout << e << endl;
}
}
void test03()
{
String str[] = { "abc","xyz","lmn" };
vector<String>v;
v.push_back(str[0]);
v.push_back(str[1]);
v.push_back(str[2]);
for (auto e : v)
{
cout << e << endl;
}
}
void main()
{
test02();
system("pause");
}
string类的接口测试:
#include<iostream>
#include<string>
using namespace std;
void test01()
{
//C语言没有真正的字符串
char str[] = "abc";
const char* pstr = "abc";
//C++
string s;
cout << "s="<<s << endl;
string s1(pstr);
cout << "s1=" << s1 << endl;
string s2("xyz");
cout << "s2=" << s2 << endl;
string s3(3, 'f');
cout << "s3=" << s3 << endl;
string s4 = s3;
cout << "s4=" << s4 << endl;
}
void test02()
{
string s3(3, 'f');
cout << "s3.size()=" << s3.size() << endl;//3 有效长度
cout << "s3.length()=" << s3.length() << endl;//3 功能和实现在底层与size相同
cout << "s3.capacity()=" << s3.capacity() << endl;
s3.append("ajghoajgoqjgnoqjngoqn");
cout << "s3.capacity()=" << s3.capacity() << endl;//底层空间会扩容
s3.clear();
cout << "s3=" << s3 << endl;
cout << "s3.size()=" << s3.size() << endl;//0 有效长度
cout << "s3.capacity()=" << s3.capacity() << endl;//空间不会缩
}
void test03()
{
string s1("abc");
s1.reserve(100);//预留空间
cout << "s3=" << s1 << endl;
cout << "s3.size()=" << s1.size() << endl;
cout << "s3.length()=" << s1.length() << endl;
cout << "s3.capacity()=" << s1.capacity() << endl;
s1.resize(10);//以a填充?
cout << "s3=" << s1 << endl;
cout << "s3.size()=" << s1.size() << endl;
cout << "s3.length()=" << s1.length() << endl;
cout << "s3.capacity()=" << s1.capacity() << endl;
s1.resize(20, 's');//大小默认用a填充,容量以\0填充
cout << "s3=" << s1 << endl;
cout << "s3.size()=" << s1.size() << endl;
cout << "s3.length()=" << s1.length() << endl;
cout << "s3.capacity()=" << s1.capacity() << endl;
}
void test04()//利用reserve提高插入数据的效率,避免增容带来的开销
{
}
void test05()
{
string s("abcxyz"); //C语言的字符串可以直接输出
cout << "s=" << s << endl;
for (int i = 0; i < s.size(); ++i)
{
cout << s[i];
}
cout << endl;
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it;
++it;
}
cout << endl;
for (auto e : s)
{
cout << e;
}
cout << endl;
const string s1 = "ajfoqojgoqhgkqnfq9";
string::const_iterator cit = s1.cbegin();//注意是cbegin不是begin
while (cit != s1.cend())
{
cout << *cit;
++cit;
}
cout << endl;
string::const_reverse_iterator rit = s1.rbegin();
while (rit != s1.rend())
{
cout << *rit;
++rit;
}
cout << endl;
}
void test06()
{
string s("abc");
s.push_back('s');//尾插只能插字符
cout << s << endl;
s.append("fgh");
cout << s << endl;
}
void test07()
{
string s1 = "abc";
string s2 = "xyz";
string s3 = s1 + s2;
cout << "s1=" << s1 << endl;
cout << "s2=" << s2 << endl;
cout << "s3=" << s3 << endl;
s1 += s2;
cout << "s1=" << s1 << endl;
}
void test08()
{
//转换成c风格字符串,即字符指针
string s1 = "abc";
cout<<strlen(s1.c_str())<<endl;
string s2;
s2.resize(10);
cout << "s2=" << s2 << endl;
cout << "s2.zize=" << s2.size() << endl;//打印10,以\0填充
cout << "s2.size=" << strlen(s2.c_str()) << endl;//打印0 识别\0之前的部分
}
void test09()
{
string s("abcxyz");
//int pos = s.find('x');//从头找
//int pos =s.find('x',4);//从指定位置开始找
//int pos = s.find("cxy",3);
int pos = s.find("cxy", 2,4);//分别为查找目标,查找位置,查找目标中的几个字符
cout << "pos=" << pos << endl;
if (pos == string::npos)
cout << "没有找到" << endl;
else
cout << "找到了,pos=" << pos << endl;
}
void test10()
{
string s("abcxyz");
string ret=s.substr(3,2);//从某个位置截取n个字符串将其返回
cout << "ret=" << ret << endl;
cout << "s=" << s << endl;
}
void test11()
{
//正则表达式
string file("string.cpp");
string email = "xxxxx@qq.com";
size_t pos = file.rfind('.');
string suffix(file.substr(pos, file.size() - pos));
cout << suffix << endl;
}
void test12()
{
string s("string.cpp");
s += 'c';//可+=字符和字符串
s += "java";
}
void test13()
{
string s1 = "abc";
string s2 = "xyz";
string s3 = s1 + s2;
//cout << "s3=" << s3 << endl;
string str;
//cin >> str;//有空格会剪短
getline(cin, str,' ');
cout << "str=" << str << endl;
}
void test14()
{
string s1 = "abc";
string s2 = "abc";
string s3 = s1 + s2;
if (s1 > s2)
{
cout << "s1>s2" << endl;
}
else if(s1<s2)
{
cout << "s1<s2" << endl;
}
else
{
cout << "s1==s1" << endl;
}
}
void main()
{
test14();
system("pause");
}
巧用临时对象,实现string类的构造、拷贝构造和赋值操作。
注意当采用系统默认提供的拷贝构造和赋值操作时,会造成浅拷贝的问题,所以要明确给出拷贝构造和赋值运算符重载函数。
这里主要是避免浅拷贝,实现深拷贝,同时利用了临时对象生命周期为函数体内部,函数执行完毕临时对象会自动调用析构函数进行数据的释放,不需要手动delete。
其实浅拷贝和深拷贝各有其优缺点,通过引用计数实现的写时拷贝能够够将二者的优点结合(读时为浅拷贝,写时为深拷贝)。
引用计数:用来记录资源使用者的个数。在构造时,将资源的计数给成 1 ,每增加一个对象使用该资源,就给
计数增加 1 ,当某个对象被销毁时,先给该计数减 1 ,然后再检查是否需要释放资源,如果计数为 1 ,说明该
对象时资源的最后一个使用者,将该资源释放;否则就不能释放,因为还有其他对象在使用该资源。
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
using namespace std;
namespace test
{
class string
{
public:
/*string()
:_str(new char[1])
{*_str = '\0';}
*/
//string(const char* str = "\0") 错误示范
//string(const char* str = nullptr) 错误示范
//现代写法
string(const string& s):_str(nullptr)
{
string tmp(s._str);
swap(_str, tmp._str);
}
//现代写法
string& operator=( string& s)//异常安全
{
if (this != &s)
{
string tmp(s);//拷贝构造
//string tmp(s._str);//有参构造
swap(_str, s._str);
}
return *this;
}
/*string& operator=(string& s)//异常安全
{
if (this != &s)
{
char* newstr = new char[strlen(s._str) + 1];
strcpy(newstr, s._str);
delete[] this->_str;
this->_str = newstr;
}
return *this;
}*/
//传统写法
/* string& operator=(const string& s)//异常不安全的代码,申请新空间之前先释放了旧空间,申请有可能不成功
{
if (this != &s)
{
delete[] _str;
_str = new char[strlen(s._str) + 1];
strcpy(_str, s._str);
}
return *this;
}*/
//传统写法
//string(const string& s) :_str(new char[strlen(s._str) + 1])//初始化列表方式
//{
// strcpy(_str, s._str);
//}
string(const char* str = "")
{
// 构造string类对象时,如果传递nullptr指针,认为程序非法,此处断言下
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
~string()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};
}
// 测试
void Teststring()
{
test::string s1("abc");
test::string s2(s1);//浅拷贝
test::string s3("xyz");
s3 = s1;//浅赋值
}
void main()
{
Teststring();
system("pause");
}
string类模拟实现:
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
using namespace std;
//字符串的模拟实现
namespace hym
{
class string
{
friend ostream& operator<<(ostream& cout, const string& s);
public:
static size_t npos;
typedef char* iterator;
string() :_str(nullptr), _size(0), _capacity(0) {}
string(const char* str)
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
string(const string& s):_str(nullptr),_size(0),_capacity(0)
{
string tmp(s._str);
swap(*this,tmp);
}
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);//
swap(*this, tmp);
}
return *this;
}
size_t size()const
{
return _size;
}
size_t capacity()const
{
return _capacity;
}
bool empty()const
{
return _size == 0;
}
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
void push_back(char c)
{
if (_size + 1 > _capacity)
{
int n = _capacity == 0 ? 1 : _capacity * 2;
reserve(n);
}
_str[_size++] = c;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t sz = strlen(str);
if (_size + sz > _capacity)
{
reserve(sz + _size);
}
strcat(_str, str);
_size += sz;
}
string& operator+=(const char c)
{
push_back(c);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
string& operator+=(const string& s)
{
append(s._str);
return *this;
}
char& operator[](int i)
{
assert(i >= 0 && i < _size);
return _str[i];
}
const char& operator[](int i)const
{
assert(i >= 0 && i < _size);
return _str[i];
}
const char* c_str() const
{
return _str;
}
void reserve(int n)
{
if (n > _capacity)
{
char* new_str = new char[n + 1];
memset(new_str, 0, n + 1);
if (_str != nullptr)
{
memcpy(new_str, _str, _capacity + 1);
}
_capacity = n;
delete[] _str;
_str = new_str;
}
}
void resize(int new_sz, char ch = '\0')
{
if (new_sz > _capacity);
{
reserve(new_sz);
for (int i = _size; i < new_sz; ++i)
{
_str[i] = ch;
}
}
_size = new_sz;
_str[_size] = '\0';
}
bool operator<(const string& s)
{
return (strcmp(_str, s._str) < 0);
}
bool operator<=(const string& s)
{
return !(operator>(s));
}
bool operator>(const string& s)
{
return (strcmp(_str, s._str) > 0);
}
bool operator>=(const string& s)
{
return !(operator<(s));
}
bool operator==(const string& s)
{
return (strcmp(_str, s._str) == 0);
}
bool operator!=(const string& s)
{
return !(operator==(s));
}
static void swap(string& s1,string& s2)
{
std::swap(s1._str, s2._str);
std::swap(s1._size, s2._size);
std::swap(s1._capacity, s2._capacity);
}
size_t find(char c, size_t pos = 0) const
{
for (int i = pos; i < _size; ++i)
{
if (_str[i] == c)
return i;
}
return npos;
}
size_t rfind(char c, size_t pos = npos) const
{
int newpos = (pos == npos ? _size - 1 : pos);
for (int i = newpos - 1; i > 0; --i)
{
if (_str[i] == c)
return i;
}
return npos;
}
size_t find(const char* s, size_t pos = 0) const
{
int i = pos;//_str
int j = 0;//s
while (i < _size && j < strlen(s))
{
if (_str[i] == s[j])
{
++i;
++j;
}
else
{
j = 0;
i = i - j + 1;
}
}
if (j > strlen(s))
return i - strlen(s);
return npos;
}
/*size_t find(const char* s, size_t pos = 0) const
{
char* t = _str + pos;
const char* ps = s;
while (*ps != '\0'&&*t !='\0')
{
if (*ps != *t)
{
ps = s;
}
else
{
ps++;
}
t++;
}
if (*ps == '\0')
return t - _str - strlen(s);
return npos;
}*/
string& insert(size_t pos, char c)
{
if (_size + 1 > _capacity)
{
reserve(_capacity*2);
}
for (int i = _size; i > pos; --i)
{
_str[i] = _str[i - 1];
}
_str[pos] = c;
_size++;
return *this;
}
string& insert(size_t pos, const char* str)
{
int len = strlen(str);
if (_size + len> _capacity)
{
reserve(_capacity +len);
}
for (int i = _size; i >=pos; --i)
{
_str[i+len] = _str[i];
}
int j = 0;
for (int i = pos; j < len; ++i,++j)
{
_str[i] = str[j];
}
_size+=len;
return *this;
}
string& erase(size_t pos, size_t len)
{
char* tmp = new char[_size - len + 1];
memset(tmp, 0, _size - len + 1);
strncpy(tmp, _str, pos);
strncat(tmp, _str + pos + len, _size - pos - len + 1);
strcpy(_str, tmp);
_size -= len;
delete[] tmp;
return *this;
}
void clear()
{
_size = 0;
_str[_size] = '\0';
}
~string()
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
private:
char* _str;
size_t _size;
size_t _capacity;
};
size_t string::npos= (size_t)-1;
ostream& operator<<(ostream& cout, const string& s)
{
cout << s._str;
return cout;
}
bool operator!=(const string& s1, const string& s2)
{
return (strcmp(s1.c_str(), s2.c_str()));
}
}
void test01()
{
hym::string s;
hym::string s1("hello");
cout << "s1= " << s1 << endl;
cout << "s1.size" << s1.size() << endl;
cout << "s1.capccity" << s1.capacity() << endl;
s1.reserve(100);
cout << "s1= " << s1 << endl;
cout << "s1.size" << s1.size() << endl;
cout << "s1.capccity" << s1.capacity() << endl;
}
void test02()
{
/*hym::string s1("hello");
s1.push_back('c');*/
hym::string s1;
for (int i = 0; i < 10; ++i)
{
s1.push_back('a' + i);
}
cout << "s1= " << s1 << endl;
cout << "s1.size=" << s1.size() << endl;
cout << "s1.capccity=" << s1.capacity() << endl;
}
void test03()
{
hym::string s1("xyz");
//s1.append("abc");
hym::string s2("abc");
s1 += 'a';
s1 += "ABC";
s1 += s2;
cout << "s1=" << s1 << endl;
}
void test04()
{
hym::string s1("xyz");
cout << strlen(s1.c_str()) << endl;
}
void test05()
{
hym::string s1("xyz");
for (int i = 0; i < s1.size(); i++)
{
cout << s1[i];
}
cout << endl;
s1[2] = 'X';
cout << s1[2] << endl;
}
void test06()
{
hym::string s1("abcXYZabc");
for (auto& e : s1)
{
cout << e;
}
cout << endl;
hym::string::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it++;
}
cout << endl;
}
void test07()
{
hym::string s1("abcdef");
s1.resize(9,'@');
cout << "s1= " << s1 << endl;
cout << "s1.size=" << s1.size() << endl;
cout << "s1.capccity=" << s1.capacity() << endl;
}
void test08()
{
hym::string s1("xyzabc");
hym::string s2("xyzabc");
if (s1 == s2)
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
}
void test09()
{
hym::string s1("xyzabc");
hym::string s2(s1);
hym::string s3 = s1;
cout << "s3= " << s3 << endl;
cout << "s3.size=" << s3.size() << endl;
cout << "s3.capccity=" << s3.capacity() << endl;
}
void test10()
{
hym::string s1("xyzabc");
//cout << s1.find('a') << endl;
if (s1.find('z') == hym::string::npos)
cout << "NO" << endl;
else
cout << " YES" << endl;
}
void test11()
{
hym::string s("abcxyzyc");
cout << s.rfind('y',5) << endl;
}
void test12()
{
hym::string s("abcdefaxyz");
cout<<s.find("axy")<<endl;
}
void test13()
{
hym::string s("abcdefgh");
int pos = s.find('f');
//s.insert(pos, '&');
//s.insert(5, "lll");
s.erase(3, 3);
cout << s << endl;
}
void test14()
{
hym::string s("abcde");
s.clear();
cout << "s.size=" << s.size() << endl;
cout << s << endl;
if (s.empty())
{
cout << "empty" << endl;
}
else
{
cout << "not empty" << endl;
}
}
void test15()
{
hym::string s1("abc");
hym::string s2("adc");
if (s1 == s2)
cout << "s1==s2" << endl;
else
cout << "s1!=s2" << endl;
if (s1 > s2)
cout << "s1>s2" << endl;
else
cout << "s1<=s2" << endl;
if (s1 < s2)
cout << "s1<s2" << endl;
else
cout << "s1>=s2" << endl;
}
void main()
{
test15();
system("pause");
}