C++STL库中的string


文章目录

  • STL库对于string类的介绍

  • string常用接口

  • string类的模拟实现
  • string对象大小的计算
  • 写时拷贝


前言

        C语言中,字符串是以'\0'结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。


一、STL库对于string类的介绍

官方介绍:

  1. 字符串是表示字符序列的对象
  2. 标准的字符串类提供了对此类对象的支持,其接口类似于标准字符容器的接口,但添加了专门用于操作单字节字符字符串的设计特性
  3. string 类是使用 char (即作为它的字符类型,使用它的默认 char_traits 和分配器类型(关于模板的更多信息,请参阅 basic_string)
  4. string 类是 basic_string 模板类的一个实例,它使用 char 来实例化 basic_string 模板类,并用 char_traits 和 allocator 作为 basic_string 的默认参数(关于更多的模板信息请参考 basic_string)
  5. 注意,这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列,这个类的所有成员(如长度或大小)以及它的迭代器,将仍然按照字节(而不是实际编码的字符)来操作

总结:

  1. string 是表示字符串的字符串类
  2. 该类的接口与常规容器的接口基本相同,再添加了一些专门用来操作 string 的常规操作
  3. string 在底层实际是 basic_string 模板类的别名 typedef basic_string string;
  4. 不能操作多字节或者变长字符的序列

二、string常用接口

1. string类对象的常见构造

string类对象的常见构造

default (1)
string();
copy (2)
string (const string& str);
substring (3)
string (const string& str, size_t pos, size_t len = npos);
from c-string (4)
string (const char* s);
from sequence (5)
string (const char* s, size_t n);
fill (6)
string (size_t n, char c);
range (7)
template   string  (InputIterator first, InputIterator last);

 常见构造代码演示:

#include
#include

using namespace std;

int main()
{
	string s0("hello");
	string s1;
	string s2(s0);
	string s3("hello world");
	string s4("hello world", 4);
	string s5(10, 'x');
	string s6(s0.begin(), s0.end());
	return 0;
}

C++STL库中的string_第1张图片

注意:空串并不是没有,而是第一个字符放的\0,存储空间不为0

 2. string类对象的容量操作

函数名称                                                                        功能说明
size (重点)                                                         返回字符串有效字符长度
length                                                                     返回字符串有效字符长度
capacity                                                                        返回空间总大小
empty (重点)                                    检测字符串释放为空串,是返回true,否则返回false
clear (重点)                                                                 清空有效字符
reserve (重点)                                                         为字符串预留空间**
resize (重点)                         将有效字符的个数该成n个,多出的空间用字符 c 填充

// 测试string容量相关的接口
// size/clear/resize
void Teststring1()
{
	// 注意:string类对象支持直接用cin和cout进行输入和输出
	string s("hello, bit!!!");
	cout << s.size() << endl;
	cout << s.length() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;

	// 将s中的字符串清空,注意清空时只是将size清0,不改变底层空间的大小
	s.clear();
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	// 将s中有效字符个数增加到10个,多出位置用'a'进行填充
	// “aaaaaaaaaa”
	s.resize(10, 'a');
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	// 将s中有效字符个数增加到15个,多出位置用缺省值'\0'进行填充
	// "aaaaaaaaaa\0\0\0\0\0"
	// 注意此时s中有效字符个数已经增加到15个
	s.resize(15);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;

	// 将s中有效字符个数缩小到5个
	s.resize(5);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
}

//====================================================================================
void Teststring2()
{
	string s;
	// 测试reserve是否会改变string中有效元素个数
	s.reserve(100);
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	// 测试reserve参数小于string的底层空间大小时,是否会将空间缩小
	s.reserve(50);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
}


注意:
          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不会改变容量大小。

在不同平台下reserve的扩容机制

// 构建vector时,如果提前已经知道string中大概要放多少个元素,可以提前将string中空间设置好
void TestPushBackReserve()
{
	string s;
	s.reserve(100);
	size_t sz = s.capacity();

	cout << "making s grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}

在Linux平台下的vim:

C++STL库中的string_第2张图片

在VS2020平台下是:

C++STL库中的string_第3张图片

结论:VS下是1.5倍扩容,Linux下是2倍扩容

3. string类对象的访问及遍历操作

函数名称                                                                                功能说明
operator[] (重点)                         返回pos位置的字符, const string 类对象调用
begin + end         begin 获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器
rbegin + rend           begin 获取一个字符的迭代器 + end 获取最后一个字符下一个位置的迭
                               代器范围forC++11 支持更简洁的范围 for 的新遍历方式
// string的遍历
// begin()+end()   for+[]  范围for
// 注意:string遍历时使用最多的还是for+下标 或者 范围for(C++11后才支持)
// begin()+end()大多数使用在需要使用STL提供的算法操作string时,比如:采用reverse逆置string
void Teststring3()
{
	string s1("hello Bit");
	const string s2("Hello Bit");
	cout << s1 << " " << s2 << endl;
	cout << s1[0] << " " << s2[0] << endl;

	s1[0] = 'H';
	cout << s1 << endl;

	// s2[0] = 'h';   代码编译失败,因为const类型对象不能修改
}

void Teststring4()
{
	string s("hello Bit");
	// 3种遍历方式:
	// 需要注意的以下三种方式除了遍历string对象,还可以遍历是修改string中的字符,
	// 另外以下三种方式对于string而言,第一种使用最多
	// 1. for+operator[]
	for (size_t i = 0; i < s.size(); ++i)
		cout << s[i] << endl;

	// 2.迭代器
	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << endl;
		++it;
	}

	// string::reverse_iterator rit = s.rbegin();
	// C++11之后,直接使用auto定义迭代器,让编译器推到迭代器的类型
	auto rit = s.rbegin();
	while (rit != s.rend())
		cout << *rit << endl;

	// 3.范围for
	for (auto ch : s)
		cout << ch << endl;
}

4. string类对象的修改操作

函数名称                                                                               功能说明
push_back                                                                  在字符串后尾插字符 c
append                                                                        在字符串后追加一个字符串
operator+= (重点)                                                         在字符串后追加字符串str
c_str (重点)                                                                         返回C格式字符串
find + npos (重点)           从字符串pos位置开始往后找字符 c ,返回该字符在字符串中的位置
r find                                 从字符串 pos 位置开始往前找字符 c ,返回该字符在字符串中的位置
substr                                          str 中从 pos 位置开始,截取 n 个字符,然后将其返回

// 测试string:
// 1. 插入(拼接)方式:push_back  append  operator+= 
// 2. 正向和反向查找:find() + rfind()
// 3. 截取子串:substr()
// 4. 删除:erase
void Teststring5()
{
	string str;
	str.push_back(' ');   // 在str后插入空格
	str.append("hello");  // 在str后追加一个字符"hello"
	str += 'b';           // 在str后追加一个字符'b'   
	str += "it";          // 在str后追加一个字符串"it"
	cout << str << endl;
	cout << str.c_str() << endl;   // 以C语言的方式打印字符串

	// 获取file的后缀
	string file("string.cpp");
	size_t pos = file.rfind('.');
	string suffix(file.substr(pos, file.size() - pos));
	cout << suffix << endl;

	// npos是string里面的一个静态成员变量
	// static const size_t npos = -1;

	// 取出url中的域名
	string url("http://www.cplusplus.com/reference/string/string/find/");
	cout << url << endl;
	size_t start = url.find("://");
	if (start == string::npos)
	{
		cout << "invalid url" << endl;
		return;
	}
	start += 3;
	size_t finish = url.find('/', start);
	string address = url.substr(start, finish - start);
	cout << address << endl;

	// 删除url的协议前缀
	pos = url.find("://");
	url.erase(0, pos + 3);
	cout << url << endl;
}
注意:
         1. 在string尾部追加字符时,s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多,一般情况下string类的+=操作用的比较多,+=操作不仅可以连接单个字符,还可以连接字符串。
        2. 对string操作时,如果能够大概预估到放多少字符,可以先通过reserve把空间预留好。

5. string类非成员函数

函数                                                                                功能说明
operator+                                          尽量少用,因为传值返回,导致深拷贝效率低
operator>> (重点)                                                 输入运算符重载
operator<< (重点)                                                 输出运算符重载
getline (重点)                                                         获取一行字符串
relational operators (重点)                                       大小比较

6.string的特殊判断接口

C语言头文件中处理字符的接口:

1.字符串处理函数:

  • int isalpha(int c):检查字符是否为字母,是返回非零(true),不是则返回0(false)
  • int isdigit(int c):检查字符是否为十进制数字,是返回非零(true),不是则返回0(false)

2.字符转换函数:

  • int tolower(int c):把字母转换成小写字母,返回转换之后的字符
  • int toupper(int c):把字母转换成大写字母,返回转换之后的字符

C++头文件中处理字符的接口:

1.函数 std::to_string(C++11):将数值转换为字符串,返回 string 类对象

2.函数 std::stoi(C++11):将字符串转换为整数,返回 int 整数

三、string类的模拟实现

namespace String
{
    class string
    {
	private:
        char* _str;       // 指向字符数组
        size_t _size;     // 有效字符数
        size_t _capacity; // 有效字符容量,不包含最后作标识的'\0'

        static const size_t npos;

	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(const char* str = ""); // 默认构造函数
        void swap(string& s); // 交换两个对象的内容
        string(const string& s); // 拷贝构造函数(深拷贝)
        string& operator=(string s); // 赋值运算符重载(深拷贝)
        ~string(); // 析构函数

        /*******************************************************/
        // 访问元素,[]运算符重载
        
        char& operator[](size_t pos);             // 可读可写
        const char& operator[](size_t pos) const; // 只读不能写

        /*******************************************************/
		// 容量操作:
        
        // 获取字符串有效元素个数
        size_t size() const { return _size; } 
        // 获取字符串容量(有效字符的最大容量)
        size_t capacity() const { return _capacity; } 
        // 清空有效字符
        void clear() 
        {
            _str[0] = '\0';
            _size = 0;
        }
        // 更改容量(capacity)的大小
        void reserve(size_t n); 
        // 调整字符串有效字符的长度
        void resize(size_t n, char ch = '\0'); 

		/*******************************************************/
        // 修改操作:
        
        string& insert(size_t pos, const char ch); // 在pos位置插入一个字符
        
        string& insert(size_t pos, const char* str); // 在pos位置插入一个字符串
        
        void push_back(const char ch); // 尾插一个字符
        
        void append(const char* str); // 在当前字符串末尾追加一个字符串
        
        string& operator+=(const char ch); // 当前字符串末尾追加一个字符/字符串
        string& operator+=(const char* str);
        string& operator+=(const string& s);        
        
        string& erase(size_t pos = 0, size_t len = npos); // 删除从pos位置开始的len个字符
        
        /*******************************************************/
        // String operations
        
        // 从pos位置开始查找字符,若找到,则返回该字符的下标,若没找到,则返回npos
        size_t find(char ch, size_t pos = 0) const;

        // 从pos位置开始查找子串,若找到,则返回该子串首字符的下标,若没找到,则返回npos
        size_t find(const char* str, size_t pos = 0) const;
		
        // 返回指向 C 格式字符串的数组的指针
        char* c_str() const { return _str; }
    };

    const size_t string::npos = -1;
};

1.string的默认成员函数的模拟实现

默认构造函数:

	string(const char* str = "") {
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];

			strcpy(_str, str);
		}

交换容器内容swap函数

void swap(string& s) {
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

拷贝构造函数

string(const string& s)
				:_str(nullptr)
				,_size(0)
				,_capacity(0)
		{
			string tmp(s._str);
			swap(tmp);
		}

赋值运算符重载


		string& operator=(string s) {
			swap(s);
			return *this;
		}

析构函数

~string() {
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

2.关于string的深浅拷贝问题

浅拷贝: 也称位拷贝,编译器只是将对象中的值拷贝过来。如果对象中管理资源,最后就会导致多个对象共享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该资源已经被释放,以为还有效,所以当继续对资源进项操作时,就会发生发生了访问违规。
#include 
#include 

using namespace std;

namespace String
{
	class string
	{
	private:
		char* _str;

	public:
		// 构造函数
		string(const char* s)
			:_str(new char[strlen(s) + 1])
		{
			strcpy(_str, s);
		}

		// 析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
	};

	void test()
	{
		string s1("hello world"); // 用一个常量字符串去构造string类对象s1
		string s2(s1); // s2调用编译器默认生成的拷贝构造函数
	}
}

int main()
{
	String::test();
	return 0;
}

C++STL库中的string_第4张图片

上述String类没有显式定义其拷贝构造函数与赋值运算符重载,此时编译器会合成默认的,当用s1构造s2时,编译器会调用默认的拷贝构造。最终导致的问题是,s1、s2共用同一块内存空间,在释放时同一块 空间被释放多次而引起程序崩溃,这种拷贝方式,称为浅拷贝。

深拷贝: 如果一个类中涉及到资源的管理,其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

#include 
#include 

using namespace std;

namespace String
{
	class string
	{
	public:
		//浅拷贝
		string(const char* s)
			:_str(new char[strlen(s) + 1])
		{
			strcpy(_str, s);
		}

		// 显式定义拷贝构造函数(深拷贝)
		string(const string& s) // 保护形参不被改变,加引用防止无穷递归
			:_str(new char[strlen(s._str) + 1])  // 给新对象申请一段和原对象一样大小的空间
		{
			strcpy(_str, s._str); // 把原对象的数据一一拷贝给新对象
		}
	private:
		char* _str;
	};

	//测试代码
	void test()
	{
		string s1("hello world"); // 用一个常量字符串去构造string类对象s1
		string s2(s1); // s2调用编译器默认生成的拷贝构造函数
	}
}

int main()
{
	String::test();
	return 0;
}

C++STL库中的string_第5张图片

string的拷贝构造的深拷贝实现

传统写法:

//浅拷贝
string(const char* s)
	:_str(new char[strlen(s) + 1])
{
	strcpy(_str, s);
}

// 显式定义拷贝构造函数(深拷贝)
string(const string& s) // 保护形参不被改变,加引用防止无穷递归
    :_str(new char[strlen(s._str) + 1])  // 给新对象申请一段和原对象一样大小的空间
{
	strcpy(_str, s._str); // 把原对象的数据一一拷贝给新对象
}

//测试代码
void test()
{
	string s1("hello world"); // 用一个常量字符串去构造string类对象s1
	string s2(s1); // s2调用编译器默认生成的拷贝构造函数
}

现代写法:

// 拷贝构造函数(深拷贝)
string(const string& s)
    :_str(nullptr) // 当前对象是一个正在构造的对象,成员变量还未初始化,是一个随机值,所以先置空
{
	string tmp(s._str);   // 拿s的内容,调用构造函数构造临时对象tmp
	swap(_str, tmp._str); // 将临时对象tmp和当前对象的成员变量_str进行交换
}

//测试代码
void test()
{
	string s1("hello world"); // 用一个常量字符串去构造string类对象s1
	string s2(s1); // s2调用编译器默认生成的拷贝构造函数
}

C++STL库中的string_第6张图片

3.string的赋值运算符重载函数的深拷贝实现

传统写法:

// 显式定义赋值运算符重载(深拷贝)
string& operator=(const string& s)
{
    if (this != &s) // 防止自己给自己赋值
    {
        char* tmp = new char[strlen(s._str) + 1]; // 重新开辟一块和s一样大小的空间
        delete[] _str;                            // 释放自己的空间
        _str = tmp;
        strcpy(_str, s._str);                     // 把s的数据拷贝过来
    }
    return *this;
}

C++STL库中的string_第7张图片

现代写法:

// 赋值运算符重载(深拷贝)
// s1 = s2
// 写法一:
string& operator=(const string& s) // 传引用
{
    if (this != &s) // 防止自己给自己赋值
    {
        string tmp(s._str);   // 拿s的内容,调用构造函数构造临时对象tmp
        swap(_str, tmp._str); // 将临时对象tmp和当前对象的成员变量_str进行交换
    }
    return *this;
}

// 写法二:
string& operator=(string s) // 重点:传值
{
    // 传参时,调用拷贝构造函数,拷贝构造了一个string类对象s

    // 将拷贝构造出来的string类对象s和当前对象的成员变量_str进行交换
    swap(_str, s._str);
    
    return *this; // 返回当前对象
}

C++STL库中的string_第8张图片

4.string的迭代器模拟实现

class string
{
private:
    char* _str;       // 指向字符数组
    size_t _size;     // 有效字符数
    size_t _capacity; // 有效字符容量,不包含最后作标识的'\0'

    static const size_t npos;

public:
    /*******************************************************/
    // 迭代器
    // iterator是内嵌类型,在stirng类域里面定义的类型
    
    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; } // 返回指向最后一个字符下一个字符的迭代器
    // ...
    // ...
};
const size_t string::npos = -1;

//测试代码
void test3()
{
    string s1("hello world");

    // iterator是内嵌类型,在stirng类域里面定义的类型
    // 告诉编译器,要到string类域里面去找
    string::iterator it = s1.begin();
    while (it != s1.end())
    {
        cout << *it;
        it++;
    }
    cout << endl;

    // 范围for的原理就是被替换成迭代器
    for (auto e : s1)
    {
        cout << e;
    }
    cout << endl;
}

5.string的访问操作运算符重载模拟实现

//对于普通数组来说:越界读一般是检查不出来的,越界写会抽查,可能会检查出来
//对于string类来说:越界读写都会被检查出来,因为[]中进行了严格的检查

// 普通版本
char& operator[](size_t pos) // 可读可写
{
    assert(pos < _size);
    return _str[pos]; // *(_str + pos)
}

//const版本
const char& operator[](size_t pos) const // 只读不能写
{
    assert(pos < _size);
    return _str[pos]; // *(_str + pos)
}

6.string的容量操作函数模拟实现

resize函数

// 调整字符串有效字符的长度
void resize(size_t n, char ch = '\0')
{
	// 要调整的有效字符的长度小于原有 _size 大小
	if (n < _size)
	{
		_size = n;          // 更新有效字符个数
		_str[_size] = '\0'; // 补上字符串结束标志'\0'
	}
	// 要调整的有效字符的长度大于原有 _size 大小
	else if (n > _size)
	{
		// 要调整的有效字符的长度大于原有 _capacity 大小,先进行增容
		if (n > _capacity) reserve(n);

		// 多出的位置用字符 ch(缺省值'\0')进行填充
		for (size_t i = _size; i < n; i++)
		{
			_str[i] = ch;
		}
		_size = n;          // 更新有效字符个数
		_str[_size] = '\0'; // 补上字符串结束标志'\0'
	}
}

reserve函数


// 更改容量(capacity)的大小
void reserve(size_t n)
{
	if (n > _capacity)
	{
		// 开辟新空间
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);  // 旧空间数据拷贝到新空间

		// 释放旧空间,使用新空间
		delete[] _str;
		_str = tmp;    // 指向新空间
		_capacity = n; // 更新容量
	}
}

7.string的修改操作函数模拟实现

 insert函数

C++STL库中的string_第9张图片

// 在pos位置插入一个字符串
string& insert(size_t pos, const char* str)
{
    assert(pos >= 0 && pos <= _size);

    // 先检查是否需要扩容
    size_t len = strlen(str);
    if (_size + len >= _capacity)
    {
        reserve(_size + len);
    }

    // 挪动字符
    for (size_t i = _size + len; i >= pos + len; i--)
    {
        _str[i] = _str[i - len];
    }
    // 插入字符
    for (size_t i = 0; i < len; i++)
    {
        _str[pos++] = str[i];
    }
    _size += len; // 更新有效字符个数

    return *this;
}

push_back函数

void push_back(const char ch)
{
	//方法一:
    // 先检查是否需要扩容
    if (_size >= _capacity)
    {
    	// 防止是空串"",容量为0,扩容失败
        size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;

        reserve(newcapacity); // 扩2倍容
    }

    _str[_size] = ch;   // 尾插字符
    _size++;            // 有效字符个数+1
    _str[_size] = '\0'; // 补上字符串结束标志'\0'

  
    //方法二: 复用 insert 函数的代码 
    insert(_size, ch);
}

append函数

void append(const char* str)
{
	//方法一:
    // 先检查是否需要扩容
    size_t len = strlen(str);
    if (_size + len > _capacity)
    {
        reserve(_size + len); // 扩容
    }

    strcpy(_str + _size, str); // 尾插字符串(strcpy会拷贝'\0',并在该点停止)
    _size += len;              // 有效字符个数+len
	

    //方法二:复用 insert 函数的代码 

    insert(_size, str);
}

+=运算符重载函数

string& operator+=(const 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;
}

erase函数

string& erase(size_t pos = 0, size_t len = npos)
{
    assert(pos >= 0 && pos < _size);

    // 1. 从pos位置开始,后面的字符删除完,这是一个O(1)的操作
    if (len == npos || pos + len >= _size)
    {
        _str[pos] = '\0';
        _size = pos;
    }
    // 2. 从pos位置开始,后面的字符删除一部分,这是一个O(n)的操作
    else
    {
        strcpy(_str + pos, _str + pos + len);
        _size -= len;
    }

    return *this;
}

8.string的字符串操作函数模拟实现

find函数

size_t find(char ch, size_t pos = 0) const
{
    assert(pos >= 0 && pos < _size);

    for (size_t i = pos; i < _size; i++)
    {
        if (_str[i] == ch) return i;
    }
    return npos;
}
size_t find(const char* str, size_t pos = 0) const
{
    assert(pos >= 0 && pos < _size);

    // 在原串中去匹配子串str
    // 匹配成功,返回子串str首字符的地址
    // 匹配失败,返回空指针
    const char* p = strstr(_str + pos, str);

    if (p) return p - _str; // 通过子串str首字符的地址,计算出首字符的下标
    else return npos;
}

9.string的特殊函数模拟实现

流插入<<运算符重载

// 流插入运算符重载
ostream& operator<<(ostream& out, const string& s)
{
    // 遍历string类对象 s ,一个一个字符的插入
    for (size_t i = 0; i < s.size(); i++)
    {
        out << s[i];
    }

    return out;
}

void test6()
{
    // 一般场景下,以下两种输出没有差别
    string s1("hello");
    cout << s1 << endl;         // 编译器当成自定义类型对象处理,匹配该类型重载的<<运算符
    cout << s1.c_str() << endl; // C_str()返回char*,编译器当成字符数组处理(内置类型)

    // 但是这种场景下有区别
    string s2("hello");
    s2.resize(10);
    s2[9] = 'x'; // 最后一个字符设为'x'

    // s2 = "hello\0\0\0\0x"

    cout << s2 << endl;         // 输出所有有效字符,"hello\0\0\0\0x"
    cout << s2.c_str() << endl; // 遇到'\0'终止,"hello"
}

流提取>>运算符重载

// 流提取运算符重载
istream& operator>>(istream& in, string& s)
{
    // 一个一个字符输入
    // 遇到空格或者换行符终止输入
    char ch;
    in >> ch; // 从流中获取一个字符
    while (ch != ' ' && ch != '\n')
    {
        s += ch;  // 把提取的字符追加到sting类对象 s 中去
        in >> ch; // 继续从流中获取下一个字符
    }

    return in;
}

void test7()
{
    string s1;
    cin >> s1; // operator>>(cin, s1);
    cout << s1 << endl;
}

getline函数:获取一行字符串,直到遇到换行符 ‘\n’

istream& getline(istream& in, string& s)
{
    // 先清空所有有效字符
    s.clear();

    // 一个一个字符的输入
    // 遇到换行符终止输入
    char ch;
    ch = in.get(); // 从流中获取一个字符
    while (ch != '\n')
    {
        s += ch;       // 把获取的字符追加到string类对象 s 中去
        ch = in.get(); // 继续从流中获取下一个字符
    }
    return in;
}

关系运算符>重载:关系运算符,进行大小比较

        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 || *this == s;
		}

		bool operator<=(const string& s) const
		{
			return !(*this > s);
		}

		bool operator<(const string& s) const
		{
			return !(*this >= s);
		}

		bool operator!=(const string& s) const
		{
			return !(*this == s);
		}

四、string类对象的大小计算

注意:下述结构是在32位平台下进行验证,32位平台下指针占4个字节。
vs下string的结构
string总共占28个字节,内部结构稍微复杂一点,先是有一个联合体,联合体用来定义string中字
符串的存储空间:
         当字符串长度小于16时,使用内部固定的字符数组来存放
        当字符串长度大于等于16时,从堆上开辟空间
union _Bxty
{ // storage for small buffer or pointer to larger one
 value_type _Buf[_BUF_SIZE];
 pointer _Ptr;
 char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;
  这种设计也是有一定道理的,大多数情况下字符串的长度都小于16,那string对象创建好之后,内
部已经有了16个字符数组的固定空间,不需要通过堆创建,效率高。
  其次:还有一个size_t字段保存字符串长度,一个size_t字段保存从堆上开辟空间总的容量
最后:还有一个指针做一些其他事情。
 故总共占16+4+4+4=28个字节。   
C++STL库中的string_第10张图片

g++下string的结构
G++下,string是通过写时拷贝实现的,string对象总共占4个字节,内部只包含了一个指针,该指
针将来指向一块堆空间,内部包含了如下字段:
空间总大小
字符串有效长度
引用计数
struct _Rep_base
{
 size_type _M_length;
 size_type _M_capacity;
 _Atomic_word _M_refcount;
};
指向堆空间的指针,用来存储字符串

五、写时拷贝

写时拷贝就是一种拖延症,是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数:用来记录资源使用者的个数。在构造时,将资源的计数给成1,每增加一个对象使用该资源,就给计数增加1,当某个对象被销毁时,先给该计数减1,然后再检查是否需要释放资源,如果计数为1,说明该对象时资源的最后一个使用者,将该资源释放;否则就不能释放,因为还有其他对象在使用该资源。
写时拷贝
写时拷贝在读取是的缺陷

你可能感兴趣的:(C++初阶,c++,开发语言)