C++——模拟实现string

1.再谈string

string为什么要被计划成模板？日常使用string好像都是char*，char*不够使用吗，为什么要计划成模板呢？
1.1 关于编码

1. //计算机的存储如何区分呢？
3. int main()
4. {
5.         //比如在C语言中，有整型
6.         //如果是有符号的话，设计了原、反、补码
7.         //负数要存储它的补码，方便运算
8.         //浮点数要设计到存精度等问题
10.         int a = 0;
12.         return 0;
13. }

复制代码

那么怎样去更好地表示其它的各种文字呢？
1.2 ASCII编码

ASCII_百度百科 (baidu.com)

   ASCII编码表示美国信息技能的编码，在一开始计划时，只思量了存储美国的文字信息
  
  内存中存储字母时，不会把字母存储进去，内存中都是0、1组合的二进制代码，以是，要在二进制代码代表的值与符号间，建立一个一一映射对应的关系，这个关系表，一般称为编码表
  
ASCII表就是值与美国的文字所建立的拥有一一映射对应的关系的编码表
  

1. int main()
2. {       
3.     char str[] = "hello world";
4.         return 0;
5. }
7. //要显式时，发现它是字符串，会去查它的编码表

复制代码

1.3 unicode

同一码_百度百科 (baidu.com)

计算机向全世界推广后，不单单需要能够表示汉字，还需要能够表示其他国家的文字符号，有些国家的文字比较简单，有些可能比汉字还要复杂。因此，计划出了万国码。

   以是要表示汉字，也要使得每个汉字都对应一个数字
那怎样表示汉字呢？也是用一个byte表示一个汉字吗？
要知道1个byte才8个bit位，如许的话才只能表示256个汉字，显然不能很好地表示
  
  方案有三种：
  1.3.1 UTF-8

1. int main()
2. {
3.         //UTF-8   主流使用，一个值可能在多个字节上面存储
4.         //但windows喜欢使用gbk，linux喜欢使用UTF-8
6.         char str1[] = "hello world";//12byte
7.         char str2[] = "工大";//5byte
8.         char str3[] = "工大 hello";//可以混着使用，11byte
10.         cout << sizeof(str1) << endl;
11.         cout << sizeof(str2) << endl;
12.         cout << sizeof(str3) << endl;
14.         char* a = str3;
15.         cout << *a << endl;
17.     return 0;
18. }

复制代码

   UTF-8的缺点：变长，意味着辨认比较复杂，太差异一，好比做屏蔽时；
或是有些情况下文字不需要兼容ASCII，这时就要使用其它方式了
  
1.3.2 UTF-16

1.3.3 UTF-32

1.4计划成模板的原因

1. int main()
2. {
3.         //为了更好地兼容这两种编码，类型进行了延申
4.         //C++11之前，设计出了宽字节，一个char占据2byte
5.     //用来更好地表示其它的编码，比如UTF-16
6.        
7.     wchar_t ch1;        //宽字节
8.         cout << sizeof(ch1) << endl;//2byte
10.         char16_t ch2;
11.         char32_t ch3;
13.         cout << sizeof(ch2) << endl;//2byte
14.         cout << sizeof(ch3) << endl;//4byte
16.     return 0;
17. }

复制代码

这也是string要计划成模板的原因，它可以传差异的模板参数，好比char16_t、char32_t等，可以实用差异的编码，表示更多国家的差异的文字。

1.5作甚乱码

   好比某文字默认使用UTF-8来存储，但表现时没有使用对于的编码表来查找，就会出现乱码。
存储格式和表明方式没有对应起来
  

1.6GBK

GBK字库_百度百科 (baidu.com)
固然unicode是全世界的编码，但它未必非常适合汉字的表达。GBK是中国创造的、更适合汉字表达的编码表。

1. int main()
2. {
3.         char s1[] = "你好!!";
5.         s1[0]++;//陪
6.         s1[0]++;
7.         s1[0]++;
8.         s1[0]++;
10.         s1[3]++;//耗
11.         s1[3]++;
12.         s1[3]++;//号
14.         //在净网行动中非常有用
15.         //黑名单词库
17.     return 0;
18. }

复制代码

2.模拟实现string

2.1无参的构造和析构

1. //string.h
3. #pragma once
5. namespace jxy
6. {
7.         class string
8.         {
9.         public:
11. //初始化的顺序是按照声明的顺序，而不是初始化列表出现的顺序
13.                 string(const char* str)
14.                         :_size(strlen(str))
15.                         ,_capacity(_size)//capacity一般不算'\0'
16.                 {
17.                         _str = new char[_capacity+1];//开空间时要多开一个
18.                         strcpy(_str, str);//strcpy会把'\0'也拷贝过去
19.                 }
21.                 ~string()
22.                 {
23.                         delete[] _str;
24.                         _str = nullptr;
25.                         _size = _capacity = 0;
26.                 }
28.                 const char* c_str() const
29.                 {
30.                         return _str;
31.                 }
32.         private:
33.                 char* _str;
34.                 size_t _size;
35.                 size_t _capacity;
36.         };
38.         void test_string1()
39.         {
40.                 string s1("hello world");
41.                 cout << s1.c_str() << endl;
43.         }
44. }
47. //Test.cpp
49. #define _CRT_SECURE_NO_WARNINGS
50. #include<iostream>
51. //这里间接包了string的相关函数
53. //#include"string.h"
54. //注意，如果写在这里可能会报错，因为std的展开在下面
55. //编译器为了追求编译速度，只会向上查找
57. using namespace std;
58. #include"string.h"//编译器实际编译时是没有.h的，在预处理阶段就在.c或者.cpp展开了
60. int main()
61. {
62.         jxy::test_string1();
64.         return 0;
65. }

复制代码

2.2单参数的构造

错误示范：

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
7.                 string()
8.                         :_str(nullptr)
9.                         ,_size(0)
10.                         ,_capacity(0)
11.                 {}
13.         };
15.         void test_string1()
16.         {
17.                 string s2;
18.                 cout << s2.c_str() << endl;
19.                
20.         //这样会崩溃
21.                 //char*有个特点，自定义类型识别会以字符串去识别，会直接去解引用，遇到'\0'才终止
22.                 //这里空指针解引用就会出错
24.                 std::string s1;
25.                 cout << s1.c_str() << endl;//库里面的是没问题的
27.         }
28. }

复制代码

正确写法1：

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
7.                 string()
8.                         :_str(new char[1]{'\0'})//这里需要开空间
9.                         ,_size(0)
10.                         ,_capacity(0)
11.                 {
12.                         //_str[0] = '\0';//或者在这里初始化
13.                 }
16.         };
18.         void test_string1()
19.         {
20.                 string s2;
21.                 cout << s2.c_str() << endl;
23.         }
24. }

复制代码

正确写法2：在无参构造处给上缺省参数

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
7.                 //const char* str="\0" 这样写不够规范
8.                  
9.                 string(const char* str="")//C语言规定常量字符串后面默认有'\0'
10.                         :_size(strlen(str))
11.                         ,_capacity(_size)
12.                 {
13.                         _str = new char[_capacity+1];
14.                         strcpy(_str, str);
15.                 }
17.         };
19.         void test_string1()
20.         {
21.                 string s2;
22.                 cout << s2.c_str() << endl;
23.         }
24. }

复制代码

2.3 size、capacity和c_str

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
6.                 size_t capacity() const
7.                 {
8.                         return _capacity;
9.                 }
11.                 size_t size() const
12.                 {
13.                         return _size;
14.                 }
16.                 const char* c_str() const
17.                 {
18.                         return _str;
19.                 }
21.         };
23.         private:
24.                 char* _str;
25.                 size_t _size;
26.                 size_t _capacity;
27. }

复制代码

2.4遍历数组

2.4.1[]

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
7.                 char& operator[](size_t pos)
8.                 {
9.                         assert(pos < _size);
10.                         return _str[pos];
11.                 }
13.                 const char& operator[](size_t pos) const//给const对象使用
14.                 {
15.                         assert(pos < _size);
16.                         return _str[pos];
17.                 }
19.         };
20. //...
21. }

复制代码

2.4.2迭代器

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
7.                 typedef char* iterator;//迭代器可以实现成指针，也可以不
8.                 //可以使用原生指针来代替iterator
10.                 iterator begin()
11.                 {
12.                         return _str;
13.                 }
15.                 iterator end()
16.                 {
17.                         return _str+_size;
18.                 }
20.         };
21. //...
22. }

复制代码

2.4.3范围for

1. namespace jxy
2. {
3.         class string
4.         {
5.         //...
6.         };
8.         void test_string2()
9.         {
11. //1. []
12.                 string s1("hello world");
13.                 for (size_t i = 0; i <s1.size() ; i++)
14.                 {
15.                         cout << s1[i] << " ";
16.                 }
17.                 cout << endl;
19. //2.迭代器
20.                 string::iterator it=s1.begin();//在里面typedef的或者是内部类
22.                 while (it != s1.end())
23.                 {
24.                         cout << *it << " ";
25.                         it++;
26.                 }
27.                 cout << endl;
29. //3.范围for
30.                 //这里还支持范围for
31.                 for (auto ch : s1)//底层代码和上面的迭代器类似
32.                 {
33.                         //auto ch = *it;
34.                         cout << ch << " ";
35.                 }
36.                 cout << endl;
38.                 //范围for的本质是替换成迭代器，编译时直接替换过去
39.                 //而且有很严格的规范，名字变化一下都是不可以的
40.         }
41. }

复制代码

2.5复用reserve实现尾插

   实现尾插的三种方式：
  1.push_back
  2.append
  3.+=
  

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
7.                 void reserve(size_t n)
8.                 {
9.                         assert(n > _capacity);
11.                         char* str1 = new char[n+1];//失败会抛异常
12.                         strcpy(str1,_str);//会把'\0'拷贝过去
14.                         delete[] _str;//越界会在这里崩溃
15.                         _str = str1;
16.                         _capacity = n;
17.                 }
19.                 void push_back(char ch)
20.                 {//扩容问题
21.                         if (_size == _capacity)
22.                         {
23.                                 reserve(_capacity==0 ? 4 :_capacity * 2);
25.                         }
26.                         _str[_size] = ch;
27.                         _size++;
28.                         _str[_size] = '\0';
29.                 }
31.                 void append(const char* str)
32.                 {
33.                         size_t len = strlen(str);
34.                         if (_size + len > _capacity)
35.                         {
36.                                 reserve(_size + len);
37.                         }
39.                         strcpy(_str + _size, str);
40.                         _size += len;
41.                 }
43.                 string& operator+=(char ch)
44.                 {
45.                         push_back(ch);
46.                         return *this;
47.                 }
49.                 string& operator+=(const char* str)
50.                 {
51.                         append(str);
52.                         return *this;
53.                 }
54. //...
55.         };
57.         void test_string3()
58.         {
59.                 string s1("hello world");
60.                 cout << s1.c_str() << endl;
62.                 s1.push_back('0');
63.                 cout << s1.c_str() << endl;
65.                 s1.append("hello lxy");
66.                 cout << s1.c_str() << endl;
68.                 s1 += '$';
69.                 cout << s1.c_str() << endl;
71.                 s1+="hellox";
72.                 cout << s1.c_str() << endl;
74.         }
75. }

复制代码

2.6 insert和erase

insert错误写法：

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
6.                 void insert(size_t pos,char ch)
7.                 {
8.                         assert(pos <= _size);
9.                         if (_size == _capacity)
10.                         {
11.                                 reserve(_capacity == 0 ? 4 : _capacity * 2);
13.                         }
15.                         size_t end = _size;//头插会出问题，这里是无符号数
17.                         //int end = _size; //改为有符号数也是行不通的
18.                         //在操作符，如 >= 两边，类型不同时，会发生类型提升
19.                         //这里end虽然是有符号数，但会被提升成无符号数
20.                         while (end >= pos)
21.                         {
22.                                 _str[end + 1] = _str[end];
23.                                 end--;
24.                         }
25.                         _str[pos] = ch;
26.                         _size++;
28.                 }
29. //...
30.         };
32.         void test_string4()
33.         {
34.                 string s1("hello world");
35.                 cout << s1.c_str() << endl;
37.                 s1.insert(5, '#');
38.                 cout << s1.c_str() << endl;
40.                 s1.insert(s1.size(), '#');
41.                 cout << s1.c_str() << endl;
43.                 s1.insert(0, '#');//头插
44.                 cout << s1.c_str() << endl;
45.         }
47. }

复制代码

正确写法1：

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
6.                 void insert(size_t pos,char ch)
7.                 {
8.                         assert(pos <= _size);
9.                         if (_size == _capacity)
10.                         {
11.                                 reserve(_capacity == 0 ? 4 : _capacity * 2);
13.                         }
15.                         size_t end = _size+1;  
16.                         while (end>pos)
17.                         {
18.                                 _str[end] = _str[end-1];
19.                                 end--;
20.                         }
21.                         _str[pos] = ch;
22.                         _size++;
24.                 }
25. //...
26.         };
27. }

复制代码

正确写法2：

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
6.                 void insert(size_t pos,char ch)
7.                 {
8.                         assert(pos <= _size);
9.                         if (_size == _capacity)
10.                         {
11.                                 reserve(_capacity == 0 ? 4 : _capacity * 2);
13.                         }
15.                         int end = _size;
16.                         while (end>=(int)pos)//或者把这里强转一下，避免出现类型提升
17.                         {
18.                                 _str[end] = _str[end-1];
19.                                 end--;
20.                         }
21.                         _str[pos] = ch;
22.                         _size++;
24.                 }
25. //...
26.         };
27. }

复制代码

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
7.                 void insert(size_t pos,size_t len=npos)
8.                 {
10.                 }
12.                 void insert(size_t pos,const char* str)
13.                 {
15.                 }
17.                 void erase(size_t pos,size_t len=npos)
18.                 {
20.                 }
21.         private:
22.                 char* _str;
23.                 size_t _size;
24.                 size_t _capacity;
26. //注意
27.                 //const static size_t npos =-1;  //特例
28.                 //这里是特殊情况，按理说不能在这里初始化
29.                 //这里给值给的是缺省值，缺省值是给初始化列表使用的
30.                 //静态成员变量不会去执行初始化列表，它不属于对象，它属于整个类，按理说要在类外面初始化
31.                 //但是const修饰的静态的整型可以，所以这里既是定义，又是定义初始化
32.                
33.                 //const static double npos = 1.2;//这样都不会去支持
35.                 const static size_t npos;
36.         };
38.         const size_t string::npos = -1;
39. }

复制代码

2.7运算符重载

1. namespace jxy
2. {
3.         class string
4.         {
5.         public:
7. //运算符重载
8. //设计成非成员函数更好，便于模板的使用
9.                 bool operator<(const string& str1)
10.                 {
11.                         return strcmp(_str, str1._str)<0;
12.                 }
14.                 bool operator==(const string& str1)
15.                 {
16.                         return strcmp(_str, str1._str)==0;
17.                 }
19.                 bool operator<=(const string& str1)
20.                 {
21.                         return *this<str1 || *this==str1;
22.                 }
24.                 bool operator>=(const string& str1)
25.                 {
26.                         return !(*this<str1);
27.                 }
29.                 bool operator>(const string& str1)
30.                 {
31.                         return !(*this<=str1);
32.                 }
34.                 bool operator!=(const string& str1)
35.                 {
36.                         return !(*this == str1);
37.                 }
38. //...
39.         };
40. }

复制代码

2.8流插入

1. namespace jxy
2. {
3.         class string
4.         {
5.     public:
7.                 typedef const char* const_iterator;//const迭代器指向的内容不能修改
8.                 //指针本身可以修改，指向的内容不能修改
10.                 const_iterator begin() const
11.                 {
12.                         return _str;
13.                 }
15.                 const_iterator end() const
16.                 {
17.                         return _str + _size;
18.                 }
20.     //...
21.         };
23.         //没有必要定义为友元，想访问私有成员变量才需要定义为友元
24.         ostream& operator<<(ostream& out, const string& s)
25.         {
26.                 1.
27.                 //for (size_t i = 0; i < s.size(); i++)
28.                 //{
29.                 //        out << s[i];
30.                 //}
31.                 //return out;
33.                 //2.可以使用范围for，但要替换成const迭代器
34.                 for (auto ch : s)
35.                         out << ch;
37.                 return out;
38.         }
39. }

复制代码

2.9流提取和clear

1. namespace jxy
2. {
3.         class string
4.         {
5.     public:
6.                 void clear()
7.                 {
8.                         _str[0] = '\0';
9.                         _size = 0;
10.                 }
12.     //...
13.         };
15.         //没有必要定义为友元，想访问私有成员变量才需要定义为友元
17.         istream& operator>>(istream& in,string& s)
18.         {//流提取要从缓冲区中取一个个的字符
19.                 s.clear();
21.                 char ch;
22.                 //in >> ch; //这样写获取不到空格
23.                 ch = in.get();
24.                 while (ch != ' ' && ch != '\n')
25.                 {
26.                         s += ch;
27.                         //in >> ch;
28.                         ch = in.get();
30.                 }
31.                 return in;
32.         }
34.         void test_string6()
35.         {
36.                 string s1("hello world");
37.                 cout << s1 << endl;
39.                 cin >> s1;
40.                 cout << s1 << endl;
42.         }
43. }

复制代码

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