【C++】第十节—string类(完结篇)——详解+代码示例

hello ，好久不见！
云边有个稻草人-个人主页
C++优质专栏！~接待订阅~

目录
一、string实现时要注意的细节点
1.void string::Insert(size_t pos, char ch)
2.void string::Insert(size_t pos, const char* str)
第一种方法
第二种方法
3.到底在哪里定义static const size_t npos ？
4.实现取域名
5.拷贝—拷贝构造和赋值
6.流插入
7.三个swap
二、
2.1 经典的string类题目
2.2 浅拷贝
2.3 深拷贝
（1）【传统版写法的String类】
（2）【现代版写法的String类】
（3）【写时拷贝】（了解）
（4）扩展阅读
（5）编码
三、综合代码
string.h
string.cpp
test.cpp

---

正文开始——

一、string实现时要注意的细节点

1.void string::Insert(size_t pos, char ch)

1. void string::Insert(size_t pos, char ch)
2. {
3.         //对于任何的插入操作都要先判断空间是否充足提前预留足够的空间
4.         if (_size == _capacity)
5.         {
6.                 reserve(_capacity == 0 ? 4 : 2 * _capacity);
7.         }
8.         size_t end = _size+1;
9.         //预留出pos位置的空间进行插入操作
10.         while (end > pos)
11.         {
12.                 _str[end] = _str[end - 1];
13.                 --end;
14.         }
15.         _str[pos] = ch;
16.         _size++;
17. }

复制代码

2.void string::Insert(size_t pos, const char* str)

第一种方法

跟我们前面讲的很相似，使用强转来解决范例的题目

1. void string::Insert(size_t pos, const char* str)
2. {
3.         //还是先扩容
4.         size_t len = strlen(str);
5.         if (_size + len > _capacity)
6.         {
7.                 //扩容
8.                 size_t newCapacity = 2 * _capacity;
9.                 //扩2倍不够直接需要多少扩多少
10.                 if (newCapacity < _size + len)
11.                         newCapacity = _size + len;
12.                 reserve(newCapacity);
13.         }
15.         int end = _size;
16.         while (end >= (int)pos)
17.         {
18.                 _str[end + len] = _str[end];
19.                 end--;
20.         }
21.        
22.         //将str进行挨个插入
23.         for (size_t i = 0; i < len; i++)
24.         {
25.                 _str[pos + i] = str[i];
26.         }
27.         _size += len;
28. }

复制代码

第二种方法

是将end-len移到end指向的数据

1. void string::Insert(size_t pos, const char* str)
2. {
3.         //还是先扩容
4.         size_t len = strlen(str);
5.         if (_size + len > _capacity)
6.         {
7.                 //扩容
8.                 size_t newCapacity = 2 * _capacity;
9.                 //扩2倍不够直接需要多少扩多少
10.                 if (newCapacity < _size + len)
11.                         newCapacity = _size + len;
12.                 reserve(newCapacity);
13.         }
15.         size_t end = _size + len;
16.         while (end >= pos+len)   //end-len==pos，end==pos+len，
17.         {
18.                 _str[end] = _str[end-len];
19.                 end--;
20.         }
22.         //将str进行挨个插入
23.         for (size_t i = 0; i < len; i++)
24.         {
25.                 _str[pos + i] = str[i];
26.         }
27.         _size += len;
28. }

复制代码

3.到底在哪里定义static const size_t npos ？

（1）所有的.c或者.cpp文件在编译链接的时候都会生成.o文件（VS下叫.obj文件），.h文件在预处理的时候就在两个.cpp文件里面展开了，我们在类域外面定义的npos就会在两个.cpp里面展开，当两个.cpp文件链接合并生成可执行步伐的时候，就构成了下面报错里面的重定义，以是当静态成员变量定义和声明分离的时候要在.cpp文件里面定义，不能像以前那样在类里面声明在类外面定义。对于npos要加上const，不可修改。（2）同时npos要在定义的时候给值，对于const对象是只有定义时一次初始化的时机。（3）特殊的一点，对于静态的const（只有整型范例的数据才可以的，这算是一个特殊处理）成员变量可以在声明的时候给缺省值，那么在定义的时候就不可以再给值了。

总结一下，对于这种环境有两种解决办法

4.实现取域名

1. //取域名
2. void test_string4()
3. {
4.         lrq::string s1 = "https://mpbeta.csdn.net/mp_blog/creation/editor/147116669?spm=1000.2115.3001.4503";
5.         size_t pos1 = s1.find(':');
6.         size_t pos2 = s1.find('/', pos1 + 3);
8.         //判断是否找到目标字符
9.         if (pos1 != string::npos && pos2 != string::npos)//npos受类域影响
10.         {
11.                 lrq::string domain = s1.substr(pos1 + 3, pos2 - (pos1 + 3));//注意pos1和pos2到底指向哪些个位置
12.                 cout << domain.c_str() << endl;
13.         }
14. }

复制代码

5.拷贝—拷贝构造和赋值

我们不表现写拷贝构造和赋值拷贝（都是一种赋值行为），编译器默认都会举行浅拷贝。（1）像上面的代码将s1拷贝赋值给s2，编译器默认的浅拷贝会导致s2和s1指向同一块空间，函数结束的时候会先析构s2再析构s1导致同一块空间析构两次就会出现上面的运行瓦解；（2）还会导致内存走漏，s2之前的空间没有得到释放。（如果一个类需要表现写析构，那么一样平常就需要写拷贝构造和赋值）

1. //s1 = s3
2. string& string::operator=(const string& s)
3. {
4.         if (this != &s)
5.         {
6.                 //上来先将s1给释放掉
7.                 delete[] _str;
8.                 _str = new char[s._capacity + 1];//预留一个\0的空间
9.                 strcpy(_str, s._str);
10.                 _size = s._size;
11.                 _capacity = s._capacity;
12.         }
13.         return *this;
14. }

复制代码

6.流插入

我们输入的是abcd efg，中间包罗一个空格字符，但是ch好像并没有从缓冲区里面提取到空格，看下图，记着，cin在直接使用流提取的时候无论输入任何范例，int，char，它都会默认忽略掉空格和换行，规定以为空格和换行都是多个值之间的分割，也就无法判定什么时候结束，以是我们要举行代码的修改。

我们使用istream类里面的get，可以提取到空格和换行

1. //cin>>str,这个实现的功能和前面讲的getline很像，只不过结束字符不同而已，我们要融会贯通一下
2. istream& operator>>(istream& is, string& str)
3. {
4.         str.clear();//清空str里面原来的字符，否则会继续加在str上面，这是实现和STL里面的string::>>一样的效果
6.         char ch;
7.         ch = is.get();
8.         while (ch != ' ' && ch != '\n')
9.         {
10.                 str += ch;
11.                 ch = is.get();
12.         }
14.         return is;
15. }

复制代码

优化一下： 

1. istream& operator>>(istream& is, string& str)
2.         {
3.                 str.clear();
5.                 int i = 0;
6.                 char buff[256];
8.                 char ch;
9.                 ch = is.get();
10.                 while (ch != ' ' && ch != '\n')
11.                 {
12.                         // 放到buff
13.                         buff[i++] = ch;
14.                         if (i == 255)
15.                         {
16.                                 buff[i] = '\0';
17.                                 str += buff;
18.                                 i = 0;
19.                         }
21.                         ch = is.get();
22.                 }
24.                 if (i > 0)
25.                 {
26.                         buff[i] = '\0';
27.                         str += buff;
28.                 }
30.                 return is;
31.         }

复制代码

7.三个swap

二、

2.1 经典的string类题目

   上面已经对  string  类举行了简单的介绍，各人只要可以或许正常使用即可。在面试中，面试官总喜好让学生自己来模拟实现string  类，最重要是实现  string  类的构造、拷贝构造、赋值运算符重载以及析构函数。各人看下以下string  类的实现是否有题目？

1. // 为了和标准库区分，此处使用String
2. class String
3. {
4. public:
5.         /*String()
6.         :_str(new char[1])
7.         {*_str = '\0';}
8.         */
9.         //String(const char* str = "\0") 错误示范
10.         //String(const char* str = nullptr) 错误示范
11.         String(const char* str = "")
12.         {
13.                 // 构造String类对象时，如果传递nullptr指针，可以认为程序非
14.                 if (nullptr == str)
15.                 {
16.                         assert(false);
17.                         return;
18.                 }
19.                 _str = new char[strlen(str) + 1];
20.                 strcpy(_str, str);
21.         }
22.         ~String()
23.         {
24.                 if (_str)
25.                 {
26.                         delete[] _str;
27.                         _str = nullptr;
28.                 }
29.         }
30. private:
31.         char* _str;
32. };
33. // 测试
34. void TestString()
35. {
36.         String s1("hello bit!!!");
37.         String s2(s1);
38. }

复制代码

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

   浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来  。如果  对象中管理资源  ，末了就会  导致  多个对象共享同一份资源，当一个对象烧毁时就会将该资源释放掉，而此时另一些对象不知道该  资源已经被释放，以为尚有效，以是当继续对资源进项操作时，就会发生发生了访问违规  。就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。    可以接纳深拷贝解决浅拷贝题目，即：  每个对象都有一份独立的资源，不要和其他对象共享  。父母给每个孩子都买一份玩具，各自玩各自的就不会有题目了。   2.3 深拷贝

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

（1）【传统版写法的String类】

1. class String
2. {
3. public:
4.         String(const char* str = "")
5.         {
6.                 // 构造String类对象时，如果传递nullptr指针，可以认为程序非
7.                 if (nullptr == str)
8.                 {
9.                         assert(false);
10.                         return;
11.                 }
12.                 _str = new char[strlen(str) + 1];
13.                 strcpy(_str, str);
14.         }
15.         String(const String& s)
16.                 : _str(new char[strlen(s._str) + 1])
17.         {
18.                 strcpy(_str, s._str);
19.         }
20.         String& operator=(const String& s)
21.         {
22.                 if (this != &s)
23.                 {
24.                         char* pStr = new char[strlen(s._str) + 1];
25.                         strcpy(pStr, s._str);
26.                         delete[] _str;
27.                         _str = pStr;
28.                 }
29.                 return *this;
30.         }
31.         ~String()
32.         {
33.                 if (_str)
34.                 {
35.                                 delete[] _str;
36.                         _str = nullptr;
37.                 }
38.         }
39. private:
40.         char* _str;
41. };

复制代码

（2）【现代版写法的String类】

1. class String
2. {
3. public:
4.         String(const char* str = "")
5.         {
6.                 if (nullptr == str)
7.                 {
8.                         assert(false);
9.                         return;
10.                 }
11.                 _str = new char[strlen(str) + 1];
12.                 strcpy(_str, str);
13.         }
14.         String(const String& s)
15.                 : _str(nullptr)
16.         {
17.                 String strTmp(s._str);
18.                 swap(_str, strTmp._str);
19.         }
20.         // 对比下和上面的赋值那个实现比较好？
21.         String& operator=(String s)
22.         {
23.                 swap(_str, s._str);
24.                 return *this;
25.         }
26.         /*
27.         String& operator=(const String& s)
28.         {
29.         if(this != &s)
30.         {
31.         String strTmp(s);
32.         swap(_str, strTmp._str);
33.         }
34.         return *this;
35.         }
36.         */
37.         ~String()
38.         {
39.                 if (_str)
40.                 {
41.                         delete[] _str;
42.                         _str = nullptr;
43.                 }
44.         }
45. private:
46.         char* _str;
47. };

复制代码

（3）【写时拷贝】（了解）

   写时拷贝就是一种拖延症，是在浅拷贝的底子之上增加了引用计数的方式来实现的。     引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成  1  ，每增加一个对象使用该资源，就给计数增加1  ，当某个对象被烧毁时，先给该计数减  1  ，然后再检查是否需要释放资源，如果计数为1  ，说明该对象时资源的末了一个使用者，将该资源释放；否则就不能释放，因为尚有其他对象在使用该资源。        写时拷贝       写时拷贝在读取时的缺陷    （4）扩展阅读

   面试中string的一种精确写法
  STL 的string类怎么啦？
  （5）编码

三、综合代码

string.h

1. #define _CRT_SECURE_NO_WARNINGS 1
3. #pragma once
4. #include<iostream>
5. #include<assert.h>
6. using namespace std;
8. namespace bit
9. {
10.         class string
11.         {
12.         public:
13.                 //typedef char* iterator;
14.                 using iterator = char*;
15.                 using const_iterator = const char*;
17.                 //string();
18.                 string(const char* str = "");
19.                 string(const string& s);
20.                 string& operator=(string s);
21.                 ~string();
23.                 void reserve(size_t n);
24.                 void push_back(char ch);
25.                 void append(const char* str);
26.                 string& operator+=(char ch);
27.                 string& operator+=(const char* str);
29.                 void insert(size_t pos, char ch);
30.                 void insert(size_t pos, const char* str);
31.                 void erase(size_t pos, size_t len = npos);
33.                 size_t find(char ch, size_t pos = 0);
34.                 size_t find(const char* str, size_t pos = 0);
36.                 char& operator[](size_t i)
37.                 {
38.                         assert(i < _size);
40.                         return _str[i];
41.                 }
43.                 const char& operator[](size_t i) const
44.                 {
45.                         assert(i < _size);
47.                         return _str[i];
48.                 }
50.                 iterator begin()
51.                 {
52.                         return _str;
53.                 }
55.                 iterator end()
56.                 {
57.                         return _str+_size;
58.                 }
60.                 const_iterator begin() const
61.                 {
62.                         return _str;
63.                 }
65.                 const_iterator end() const
66.                 {
67.                         return _str + _size;
68.                 }
70.                 size_t size() const
71.                 {
72.                         return _size;
73.                 }
75.                 const char* c_str() const
76.                 {
77.                         return _str;
78.                 }
80.                 void clear()
81.                 {
82.                         _str[0] = '\0';
83.                         _size = 0;
84.                 }
86.                 void swap(string& s);
88.                 string substr(size_t pos, size_t len = npos);
89.         private:
90.                 char* _str = nullptr;
91.                 size_t _size = 0;
92.                 size_t _capacity = 0;
94.         public:
95.                 // ⴦
96.                 //static const size_t npos = -1;
98.                 static const size_t npos;
99.         };
101.         void swap(string& s1, string& s2);
102.         bool operator== (const string& lhs, const string& rhs);
103.         bool operator!= (const string& lhs, const string& rhs);
104.         bool operator> (const string& lhs, const string& rhs);
105.         bool operator< (const string& lhs, const string& rhs);
106.         bool operator>= (const string& lhs, const string& rhs);
107.         bool operator<= (const string& lhs, const string& rhs);
109.         ostream& operator<<(ostream& os, const string& str);
110.         istream& operator>>(istream& is, string& str);
111.         istream& operator>>(istream& is, string& str);
112.         istream& getline(istream& is, string& str, char delim = '\n');
113. }

复制代码

string.cpp

1. #include"string.h"namespace bit{        const size_t string::npos = -1;        // 11:52        /*string::string()                :_str(new char[1]{ '\0' })                , _size(0)                , _capacity(0)        {}*/        string::string(const char* str)                :_size(strlen(str))        {                _capacity = _size;                _str = new char[_size + 1];                strcpy(_str, str);        }        // 传统写法        // s2(s1)        /*string::string(const string& s)        {                _str = new char[s._capacity + 1];                strcpy(_str, s._str);                _size = s._size;                _capacity = s._capacity;        }*/        // s2(s1)        // 现代写法        string::string(const string& s)        {                string tmp(s._str);                swap(tmp);        }        // s2 = s1 = s3        // s1 = s1;        // 传统写法        /*string& string::operator=(const string& s)        {                if (this != &s)                {                        delete[] _str;                        _str = new char[s._capacity + 1];                        strcpy(_str, s._str);                        _size = s._size;                        _capacity = s._capacity;                }                return *this;        }*/        // 现代写法        // s1 = s3        string& string::operator=(string s)        {                swap(s);                return *this;        }        string::~string()        {                delete[] _str;                _str = nullptr;                _size = 0;                _capacity = 0;        }        void string::reserve(size_t n)        {                if (n > _capacity)                {                        //cout << "reserve:" << n << endl;                        char* tmp = new char[n + 1];                        strcpy(tmp, _str);                        delete[] _str;                        _str = tmp;                        _capacity = n;                }        }        void string::push_back(char ch)        {                /*if (_size == _capacity)                {                        reserve(_capacity == 0 ? 4 : _capacity * 2);                }                _str[_size] = ch;                _size++;*/                insert(_size, ch);        }        void string::append(const char* str)        {                //size_t len = strlen(str);                //if (_size + len > _capacity)                //{                //        size_t newCapacity = 2 * _capacity;                //        // 扩2倍不够，则需要多少扩多少                //        if (newCapacity < _size + len)                //                newCapacity = _size + len;                //        reserve(newCapacity);                //}                //strcpy(_str + _size, str);                //_size += len;                insert(_size, str);        }        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 : _capacity * 2);                }                /*int end = _size;                while (end >= (int)pos)                {                        _str[end + 1] = _str[end];                        --end;                }*/                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 = 2 * _capacity;                        // 扩2倍不够，则需要多少扩多少                        if (newCapacity < _size + len)                                newCapacity = _size + len;                        reserve(newCapacity);                }                /*int end = _size;                while (end >= (int)pos)                {                        _str[end + len] = _str[end];                        --end;                }*/                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 += len;        }        void string::erase(size_t pos, size_t len)        {                assert(pos < _size);                if (len >= _size - pos)                {                        _str[pos] = '\0';                        _size = pos;                }                else                {                        // 从后往前挪                        size_t end = pos + len;                        while (end <= _size)                        {                                _str[end - len] = _str[end];                                ++end;                        }                        _size -= len;                }        }        size_t string::find(char ch, size_t pos)        {                assert(pos < _size);                for (size_t i = pos; i < _size; i++)                {                        if (ch == _str[i])                                return i;                }                return npos;        }        size_t string::find(const char* str, size_t pos)        {                assert(pos < _size);                const char* ptr = strstr(_str + pos, str);                if (ptr == nullptr)                {                        return npos;                }                else                {                        return ptr - _str;                }        }        string string::substr(size_t pos, size_t len)        {                assert(pos < _size);                // 大于后面剩余串的长度，则直接取到结尾                if (len > (_size - pos))                {                        len = _size - pos;                }                bit::string sub;                sub.reserve(len);                for (size_t i = 0; i < len; i++)                {                        sub += _str[pos + i];                }                //cout << sub.c_str() << endl;                return sub;        }        void string::swap(string& s)        {                std::swap(_str, s._str);                std::swap(_size, s._size);                std::swap(_capacity, s._capacity);        }                void swap(string& s1, string& s2)        {                s1.swap(s2);        }        bool operator== (const string& lhs, const string& rhs)        {                return strcmp(lhs.c_str(), rhs.c_str()) == 0;        }        bool operator!= (const string& lhs, const string& rhs)        {                return !(lhs == rhs);        }        bool operator> (const string& lhs, const string& rhs)        {                return !(lhs <= rhs);        }        bool operator< (const string& lhs, const string& rhs)        {                return strcmp(lhs.c_str(), rhs.c_str()) < 0;        }        bool operator>= (const string& lhs, const string& rhs)        {                return !(lhs < rhs);        }        bool operator<= (const string& lhs, const string& rhs)        {                return lhs < rhs || lhs == rhs;        }        ostream& operator<<(ostream& os, const string& str)        {                //os<<'"';                //os << "xx"xx";                for (size_t i = 0; i < str.size(); i++)                {                        //os << str[i];                        os << str[i];                }                //os << '"';                return os;        }        istream& operator>>(istream& is, string& str)
2.         {
3.                 str.clear();
5.                 int i = 0;
6.                 char buff[256];
8.                 char ch;
9.                 ch = is.get();
10.                 while (ch != ' ' && ch != '\n')
11.                 {
12.                         // 放到buff
13.                         buff[i++] = ch;
14.                         if (i == 255)
15.                         {
16.                                 buff[i] = '\0';
17.                                 str += buff;
18.                                 i = 0;
19.                         }
21.                         ch = is.get();
22.                 }
24.                 if (i > 0)
25.                 {
26.                         buff[i] = '\0';
27.                         str += buff;
28.                 }
30.                 return is;
31.         }        istream& getline(istream& is, string& str, char delim)        {                str.clear();                int i = 0;                char buff[256];                char ch;                ch = is.get();                while (ch != delim)                {                        // 放到buff                        buff[i++] = ch;                        if (i == 255)                        {                                buff[i] = '\0';                                str += buff;                                i = 0;                        }                        ch = is.get();                }                if (i > 0)                {                        buff[i] = '\0';                        str += buff;                }                return is;        }}

复制代码

test.cpp

1. #include"string.h"
3. void test_string1()
4. {
5.         bit::string s2;
6.         cout << s2.c_str() << endl;
8.         bit::string s1("hello world");
9.         cout << s1.c_str() << endl;
11.         s1[0] = 'x';
12.         cout << s1.c_str() << endl;
14.         for (size_t i = 0; i < s1.size(); i++)
15.         {
16.                 cout << s1[i] << " ";
17.         }
18.         cout << endl;
20.         // 迭代器 -- 像指针一样的对象
21.         bit::string::iterator it1 = s1.begin();
22.         while (it1 != s1.end())
23.         {
24.                 (*it1)--;
26.                 ++it1;
27.         }
28.         cout << endl;
30.         it1 = s1.begin();
31.         while (it1 != s1.end())
32.         {
33.                 cout << *it1 << " ";
34.                 ++it1;
35.         }
36.         cout << endl;
38.         // 修改
39.         // 底层是迭代器的支持
40.         // 意味着支持迭代器就支持范围for
41.         for (auto& ch : s1)
42.         {
43.                 ch++;
44.         }
46.         for (auto ch : s1)
47.         {
48.                 cout << ch << " ";
49.         }
50.         cout << endl;
52.         const bit::string s3("xxxxxxxxx");
53.         for (auto& ch : s3)
54.         {
55.                 //ch++;
56.                 cout << ch << " ";
57.         }
58.         cout << endl;
59. }
61. void test_string2()
62. {
63.         bit::string s1("hello world");
64.         cout << s1.c_str() << endl;
66.         s1 += '#';
67.         s1 += "#hello world";
68.         cout << s1.c_str() << endl;
70.         bit::string s2("hello world");
71.         cout << s2.c_str() << endl;
72.         s2.insert(6, 'x');
73.         cout << s2.c_str() << endl;
75.         s2.insert(0, 'x');
76.         cout << s2.c_str() << endl;
78.         bit::string s3("hello world");
79.         cout << s3.c_str() << endl;
80.         s3.insert(6, "xxx");
81.         cout << s3.c_str() << endl;
83.         s3.insert(0, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
84.         cout << s3.c_str() << endl;
85. }
87. void test_string3()
88. {
89.         bit::string s1("hello world");
90.         cout << s1.c_str() << endl;
92.         s1.erase(6, 2);
93.         cout << s1.c_str() << endl;
95.         s1.erase(5, 20);
96.         cout << s1.c_str() << endl;
98.         s1.erase(3);
99.         cout << s1.c_str() << endl;
100. }
102. void test_string4()
103. {
104.         bit::string s1("hello world");
105.         cout << s1.find(' ') << endl;
106.         cout << s1.find("wo") << endl;
108.         bit::string s2 = "https://legacy.cplusplus.com/reference/cstring/strstr/?kw=strstr";
109.         //bit::string s2 = "https://blog.csdn.net/ww753951/article/details/130427526";
110.         size_t pos1 = s2.find(':');
111.         size_t pos2 = s2.find('/', pos1+3);
112.         if (pos1 != string::npos && pos2 != string::npos)
113.         {
114.                 bit::string domain = s2.substr(pos1 + 3, pos2 - (pos1 + 3));
115.                 cout << domain.c_str() << endl;
117.                 bit::string uri = s2.substr(pos2+1);
118.                 cout << uri.c_str() << endl;
119.         }
120. }
122. void test_string5()
123. {
124.         bit::string s1("hello world");
125.         bit::string s2(s1);
126.         cout << s1.c_str() << endl;
127.         cout << s2.c_str() << endl;
129.         s1[0] = 'x';
130.         cout << s1.c_str() << endl;
131.         cout << s2.c_str() << endl;
133.         bit::string s3("xxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
134.         s1 = s3;
135.         cout << s1.c_str() << endl;
136.         cout << s3.c_str() << endl;
138.         s1 = s1;
139.         cout << s1.c_str() << endl;
140. }
142. void test_string6()
143. {
144.         //bit::string s1("hello world");
145.         //bit::string s2(s1);
146.         //bit::string s3 = s1;
147.          构造+拷贝 ->优化直接构造
148.         //bit::string s4 = "hello world";
150.         //cout << (s1 == s2) << endl;
151.         //cout << (s1 < s2) << endl;
152.         //cout << (s1 > s2) << endl;
153.         //cout << (s1 == "hello world") << endl;
154.         //cout << ("hello world" == s1) << endl;
156.         operator<<(cout, s1);
157.         //cout << s1 << endl;
159.         //cin >> s1;
160.         //cout << s1 << endl;
161.         //
162.         //std::string ss1("hello world");
163.         //cin >> ss1;
164.         //cout << ss1 << endl;
166.         bit::string s1;
167.         //cin >> s1;
168.         //cout << s1 << endl;
170.         getline(cin, s1);
171.         cout << s1 << endl;
173.         getline(cin, s1, '#');
174.         cout << s1 << endl;
175. }
177. //void test_string7()
178. //{
179. //        bit::string s1("hello world");
180. //        bit::string s2("xxxxxxxxxxxxxxxxxxxxxxx");
181. //
182. //        //swap(s1, s2);
183. //        s1.swap(s2);
184. //        cout << s1 << endl;
185. //        cout << s2 << endl;
186. //}
188. void test_string8()
189. {
190.         bit::string s1("hello world");
191.         bit::string s2(s1);
193.         bit::string s3("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
194.         s1 = s3;
196.         cout << s1 << endl;
197.         cout << s3 << endl;
199.         char arr1[] = "types";
200.         char16_t arr2[] = u"types";
201.         char32_t arr3[] = U"types";
202.         wchar_t arr4[] = L"types";
204.         cout << sizeof(arr1) << endl;
205.         cout << sizeof(arr2) << endl;
206.         cout << sizeof(arr3) << endl;
207.         cout << sizeof(arr4) << endl;
209.         char arr5[] = "苹果 apple";
210.         cout << sizeof(arr5) << endl;
211.         arr5[1]++;
212.         arr5[1]++;
213.         arr5[1]--;
214.         arr5[1]--;
215.         arr5[1]--;
216.         arr5[1]--;
218.         arr5[3]--;
219.         arr5[3]--;
220.         arr5[3]--;
221. }
223. //int main()
224. //{
225. //        test_string8();
226. //
227. //        return 0;
228. //}
230. #include<vector>
232. int main()
233. {
234.         vector<int> v1;
235.         vector<int> v2(10, 1);
236.         v1.push_back(1);
237.         v1.push_back(2);
238.         v1.push_back(3);
239.         v1.push_back(4);
241.         // 遍历
242.         for (size_t i = 0; i < v1.size(); i++)
243.         {
244.                 cout << v1[i] << " ";
245.         }
246.         cout << endl;
248.         vector<int>::iterator it1 = v1.begin();
249.         while (it1 != v1.end())
250.         {
251.                 cout << *it1 << " ";
252.                 ++it1;
253.         }
254.         cout << endl;
256.         for (auto e : v1)
257.         {
258.                 cout << e << " ";
259.         }
260.         cout << endl;
262.         vector<string> vstr;
263.         string s1 = "张三";
264.         vstr.push_back(s1);
265.         vstr.push_back("李四");
267.         for (const auto& e : vstr)
268.         {
269.                 cout << e << " ";
270.         }
271.         cout << endl;
273.         vstr[0] += 'x';
274.         vstr[0] += "apple";
275.         //vstr[0][0]++;
276.         vstr[0][1]++;
277.         vstr[0][1]++;
278.         vstr.operator[](0).operator[](1)++;
280.         for (const auto& e : vstr)
281.         {
282.                 cout << e << " ";
283.         }
284.         cout << endl;
287.         return 0;
288. }

复制代码

完——

---

下次继续吧。。。vector
我和你—神奇阿呦

至此结束！
我是云边有个稻草人
期待与你的下一次相遇！



免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。