string();                         // 默认构造
string (const char* s);           // 用c-string来构造string类对象
string (size_t n, char c);        // 用n个字符c来构造string对象
string (const string& s);         // 拷贝构造(用已有的string类对象去构造string类对象)
===========================================================================================
string (const char* s, size_t n); // 用c-string前n个字符来构造string类对象
template <class InputIterator>    // 用迭代器[first,last)范围内的字符序列构造string类对象
string (InputIterator first, InputIterator last);


#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s0 ("Initial string");
    string s1;                                    // s1: ""
    string s2 (s0);                               // s2: Initial string
    string s4 ("A character sequence");           // s4: A character sequence
    string s5 ("Another character sequence", 12); // s5: Another char
    string s6 (10, 'x');                          // s6: xxxxxxxxxx
    string s7 (s0.begin(), s0.begin() + 7);       // s7: Initial
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

// 测试string容量相关的接口：size/length/capacity/clear/resize
void Tests1()
{
	string s("hello world!");
	cout << s.size() << endl;     //12
	cout << s.length() << endl;   //12
	cout << s.capacity() << endl; //15
	cout << s << endl;            //hello world!

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


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


	// 将s中有效字符个数增加到20个，多出位置用缺省值'\0'进行填充
    // 如果resize参数大于原有 capacity 大小，会进行增容
	// "aaaaaaaaaa\0\0\0\0\0\0\0\0\0\0"
	// 注意此时s中有效字符个数已经增加到20个
	s.resize(15);
	cout << s.size() << endl;     //20
	cout << s.capacity() << endl; //31
	cout << s << endl;            //aaaaaaaaaa


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

void TestPushBack()
{
	string s;
	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';
		}
	}
}

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';
		}
	}
}

void Tests3()
{
	string s1("hello World");
	const string s2("Hello World");
	cout << s1 << " " << s2 << endl;
	cout << s1[0] << " " << s2[0] << endl;

	s1[0] = 'H';
	cout << s1 << endl;
	// s2[0] = 'h'; //编译失败，因为const类型对象不能修改
}

// const对象必须要用const迭代器
void test(const std::string& s)
{
	string::const_iterator it = s.begin();
	while (it != s.end())
    {
		cout << *it;
        it++;
	}
}

void Tests4()
{
	string s("hello World");

	// 1、for+operator[]
	for (size_t i = 0; i < s.size(); ++i)
	{
		cout << s[i] << " ";
	}
	cout << endl;

	// 2、迭代器(正向)
	string::iterator it = s.begin();
    // 注意：这里不建议写成it<s.end()，比如链式结构的容器，就没法使用了
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

    // 2、迭代器(反向)
	// string::reverse_iterator rit = s.rbegin();
	// C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型
	auto rit = s.rbegin(); // 创建一个反向迭代器rit，指向字符串s的最后一个字符
	while (rit != s.rend()) // 当反向迭代器不等于s的逆向结束迭代器时
	{
		cout << *rit << " ";
		++rit; // 将迭代器向前移动一位
	}
	cout << endl;

	// 3、范围for(支持迭代器的容器就支持范围for)
	for (auto ch : s)
	{
		cout << ch << " ";
	}
	cout << endl;
}

void Tests5()
{
	string s;
	s.push_back(' ');  // 在s后插入空格
	s.append("hello"); // 在s后追加一个字符串"hello"
	s += 'w';          // 在s后追加一个字符'w'   
	s += "orld";       // 在s后追加一个字符串"orld"
	cout << s << endl; // helloworld
	cout << s.c_str() << endl; // 以C语言的方式打印字符串 helloworld

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

	// 取出url中的域名
	string url("http://www.cplusplus.com/reference/string/string/find/");
	cout << url << endl; //http://www.cplusplus.com/reference/string/string/find/
	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; //www.cplusplus.com

	// 删除url的协议前缀
	pos = url.find("://");
	url.erase(0, pos + 3);
	cout << url << endl; //www.cplusplus.com/reference/string/string/find/
}

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;

⚪G++ 下 string 的结构

G++ 下，string 是通过写时拷贝实现的，string 对象总共占 4 个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段：

• 空间总大小
• 字符串有效长度
• 引用计数

struct _Rep_base
{
    size_type _M_length;
    size_type _M_capacity;
    _Atomic_word _M_refcount;
};

class String
{
public:
    String(const char* str = "")
    {
        // 构造String类对象时，如果传递nullptr指针，可以认为程序非法
        if (nullptr == str)
        {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }

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

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

    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

class String
{
public:
    String(const char* str = "")
    {
        if (nullptr == str)
        {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }

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

    // 写法一(更好)
    String& operator=(String s) //传值
    {
        // 传参时，调用拷贝构造函数，拷贝构造了一个string类对象s

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

    // 写法二
    //String& operator=(const String& s) // 传引用
    //{
    //    if(this != &s) // 防止自己给自己赋值
    //    {
    //        String strTmp(s); // 拿s的内容，调用构造函数构造临时对象strTmp 
    //        swap(_str, strTmp._str); // 将临时对象strTmp 和当前对象的成员变量_str进行交换
    //    }
    //    return *this;
    //}

    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

#pragma once

#include <iostream>
#include <assert.h>
using namespace std;

namespace xyl
{
	class string
	{
	public:
		typedef char* iterator;

	public:
        // 默认构造函数
        string(const char* str = "")  // 空串并不是什么都没有，第一个字符为'\0'
            :_size(strlen(str))
	        ,_capacity(_size)
        {
	        _str = new char[_capacity + 1]; // +1是确保有足够的空间存储字符串,因为还需要额外的一个字节来存储'\0'
	        strcpy(_str, str);              // 拷贝数据
        }

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

		// 赋值运算符重载（深拷贝）
        // s1 = s2
        string& operator=(string s)
        {
            this->swap(s); // 将拷贝构造的对象s和当前对象的成员变量分别进行交换
            return *this;  // 返回当前对象
        }

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


		// iterator
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}

		
		// modify
        // 在pos位置上插入字符c，并返回该字符的位置
        // 在pos位置插入一个字符
        string& insert(size_t pos, const char ch)
        {
            assert(pos >= 0 && pos <= _size);
        
            if (_size == _capacity) // 先检查是否需要扩容
            {
                // 防止是空串""，容量为0，扩容失败
                size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;

                reserve(newcapacity);
            }
            // 挪动字符
            for (size_t i = _size + 1; i > pos; i--) // 注意
            {
                _str[i] = _str[i - 1];
            }
            _str[pos] = ch; // 插入字符
            _size++;        // 有效字符个数+1

            return *this;
        }

        // 在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;
        }

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

                reserve(newcapacity); // 扩2倍容
			}			
			_str[_size] = c;    // 尾插字符
            _size++;            // 有效字符个数+1
            _str[_size] = '\0'; // 补上字符串结束标志'\0' */

            insert(_size, ch);
		}

        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;
        }


		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;
        }


		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(_size, str);
        }


		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}


        // s1.swap(s2);
        void swap(string& s)
        {
            // 函数名冲突，指定去调用全局域里面的::swap
            ::swap(_str, s._str);
            ::swap(_size, s._size);
            ::swap(_capacity, s._capacity);
        }


		// capacity
		size_t size()const
		{
			return _size;
		}
		size_t capacity()const
		{
			return _capacity;
		}
		bool empty()const
		{
			return 0 == _size;
		}


        // 调整字符串有效字符的长度
        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'
            }
        }


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

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


		// access
		char& operator[](size_t index) // 用于访问字符串中指定位置的字符
		{
			assert(index < _size);
			return _str[index];
		}


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

		
		// 比较两个对象的大小（按字符ascii码比较）
        // s1 > s2
        bool operator>(const string& s1, const string& s2)
        {
            // 指针 i 和 j 分别指向两个字符串的第一个字符
            size_t i = 0, j = 0;
            for (; i < s1.size() && j < s2.size(); i++, j++) // 同时遍历两个字符串
            {
                if (s1[i] != s2[j]) return s1[i] > s2[j];
            }

            if (i == s1.size() && j == s2.size()) return false; // 同时被遍历完，说明 s1 = s2
            else if (i == s1.size()) return false; // s1先被遍历完，说明 s1 < s2
            else if (j == s2.size()) return true;  // s2先被遍历完，说明 s1 > s2
        }

        // s1 == s2
        bool operator==(const string& s1, const string& s2)
        {
            // 指针 i 和 j 分别指向两个字符串的第一个字符
            size_t i = 0, j = 0;
            for (; i < s1.size() && j < s2.size(); i++, j++) // 同时遍历两个字符串
            {
                if (s1[i] != s2[j]) return false;
            }

            if (i == s1.size() && j == s2.size()) return true; // 同时被遍历完，说明 s1 = s2
            else return false; // 有一个字符串没被遍历完
        }

        // 下面的关系运算符重载，全都可以复用上面的代码
        // s1 != s2
        bool operator!=(const string& s1, const string& s2) { return !(s1 == s2); }
        // s1 >= s2
        bool operator>=(const string& s1, const string& s2) { return s1 > s2 || s1 == s2; }
        // s1 < s2
        bool operator<(const string& s1, const string& s2) { return !(s1 >= s2); }
        // s1 <= s2
        bool operator<=(const string& s1, const string& s2) { return !(s1 > s2); }


		// 返回c在string中第一次出现的位置
		size_t find(char c, size_t pos = 0) const
        {
            assert(pos >= 0 && pos < _size);

            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
        {
            assert(pos >= 0 && pos < _size);

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

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

	private:
		friend ostream& operator<<(ostream& _cout, const xyl::string& s);
		friend istream& operator>>(istream& _cin, xyl::string& s);
	private:
		char* _str;
		size_t _capacity;
		size_t _size;
	};

	ostream& operator<<(ostream& _cout, const xyl::string& s)
	{
		// 不能使用cout, 因为string的字符串内部可能会包含\0
		// 直接cout时, 是将_str当成char*打印的，遇到内部的\0时后序内容就不打印了
		//cout << s._str;
		for (size_t i = 0; i < s.size(); ++i)
		{
			_cout << s[i];
		}
		return _cout;
	}

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


int main()
{
	xyl::string s1("hello");
	s1.push_back(' ');
	s1.push_back('w');
	s1.push_back('o');
	s1.push_back('r');
	s1 += 'l';
	s1 += 'd';
	cout << s1 << endl;            //hello world
	cout << s1.size() << endl;     //11
	cout << s1.capacity() << endl; //20

	// 利用迭代器打印string中的元素
	xyl::string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;

	// 这里可以看到一个类只要支持的基本的iterator，就支持范围for
	for (auto ch : s1)
	{
		cout << ch;
	}	
	cout << endl;
    return 0;
}