• C++ STL之string类模拟实现

    目录

    1.C语言必备函数

    2.构造模块

      (1)构造函数

        [1]构造函数一

        [2]构造函数二

      (2)析构函数 

      (3)拷贝构造函数

        [1]传统版本

        [2]简洁版本

      (4)赋值运算符重载 

        [1]传统版本

        [2]简洁版本

    3.容量模块

      (1)有效字符函数 

      (2)有效字符函数

      (3)扩容函数 

      (4)设置有效字符函数 

      (5)判空函数 

      (6)清空函数 

    4.迭代器模块

      (1)正向迭代器

      (2)反向迭代器

    5.访问模块

      (1)重载[]

      (2)重载cout<< 

    6.修改模块

      (1)尾插单个字符

      (2)重载+=

    7.特殊操作模块

      (1)转为C语言字符串类型

      (2)复制函数

      (3)正向查找函数

      (4)反向查找函数

    8.总体实现

             在前面的文章中已经验证了，在涉及资源管理的类中，拷贝构造函数，析构函数，赋值运算符重载函数都需要用户显示实现，如果使用编译器默认生成的，就会有浅拷贝的风险。如果有读者不理解浅拷贝，可以看下面这幅图。

            浅拷贝通俗来讲就是多个对象指向了同一块空间，例如s1与s2同时指向此空间，当s1对象中的内容修改后，s2中的内容也随之被修改了。但这不是最严重的，最严重的是如果将s1对象销毁，这块空间将被释放，可是s2还在，如果它要对自己的成员变量做修改或是销毁s2，毫无疑问程序会崩溃，因为它此时已经是个野指针了，指向了一块被释放的空间。

            在string类的模拟实现中，主要有六大模块组成：构造模块、容量模块、迭代器模块、访问模块、修改模块、特殊操作模块。因为string类的操作太多，我们只实现其中最常用的功能即可。(本文代码均在win10系统下的vs2019下运行成功)

            在六个模块中的函数均为一部分代码，不能单独运行，总体中的代码才可以运行。   

            在准备模拟string类之前，需要先来回顾一下C语言中用来操作字符串的函数：strlen、strcpy、strncpy、strcat、memset、memcpy。这些函数在模拟string类的时候都要用到。     

    1.C语言必备函数

    函数名称函数功能
    size_t strlen(const char *str)
    		计算字符串 str 的长度，直到空结束字符，但不包括空结束字符。
    char *strcpy(char *dest, const char *src)

    把 src 所指向的字符串复制到 dest。

    注意dest指向的空间要足够大。

    char *strncpy(char *dest, const char *src, size_t n)
    		把 src 所指向的字符串复制到 dest，最多复制 n 个字符。当 src 的长度小于 n 时，dest 的剩余部分将用空字节填充。
    void *memset(void *str, int c, size_t n)
    		复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。
    void *memcpy(void *str1, const void *str2, size_t n)
    		从存储区 str2 复制 n 个字节到存储区 str1。
    strcat(char* s1,char* s2)把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。

            在回顾函数之前，需要说明的是，在vs2019中这样定义一个字符串是会报错的：char* str = "abc";解决办法如下代码一：

            代码一：

    1. //代码一
    2. #include "iostream"
    3. using namespace std;
    4. #include 
    5.  
    6. int main() {
    7. 	//方法1
    8. 	const char* s1 = "abc";
    9. 	cout << s1 << endl;
    10.  
    11. 	//方法2
    12. 	char s2[] = { "1234" };
    13. 	char* p2 = s2;
    14. 	cout << p2 << endl;
    15.  
    16. 	//方法3
    17. 	char* s3 = new char[100]{ "asd" };
    18. 	cout << s3 << endl;
    19. }

            解决上述问题后，开始回顾函数，六个函数的使用都在代码二中了： 使用这些函数时，请加上#define _CRT_SECURE_NO_WARNINGS，否则编译器会因为这些函数不安全而报错。

            代码二：

    1. //代码二
    2. #define _CRT_SECURE_NO_WARNINGS
    3. #include "iostream"
    4. using namespace std;
    5. #include 
    6.  
    7. int main() {
    8. 	char* s1 = new char[100]{ "12345" };
    9. 	char* s2 = new char[100]{ "abcde" };
    10. 	char* s3 = new char[100];
    11.  
    12. 	//strlen 计算s1有效元素个数
    13. 	int len = strlen(s1);
    14. 	cout << len << endl;//5
    15.  
    16. 	//strcpy 把s2拷贝到s1中
    17. 	strcpy(s1, s2);
    18. 	cout << s1 << endl;//abcde
    19.  
    20. 	//strcpy 把s1的前2个字符拷贝到s3中
    21. 	strncpy(s3, s1, 2);
    22. 	s3[2] = '\0';
    23. 	cout << s3 << endl;//ab
    24.  
    25. 	//memset 把1个 '9'字符复制到s1的前1个位置
    26. 	memset(s1, '9', 1);
    27. 	cout << s1 << endl;//9bcde
    28.  
    29. 	//memcpy 从s1中复制4个字节到s3中
    30. 	memcpy(s3, s1, 4);
    31. 	s3[4] = '\0';
    32. 	cout << s3 << endl;//9bcd
    33.  
    34. 	//strcat 把s3指向的字符串追加到s1指向的字符串结尾
    35. 	strcat(s1, s3);
    36. 	cout << s1 << endl;//9bcde9bcd
    37. }

    2.构造模块

      (1)构造函数

            这里实现两个构造函数。

            String类中的成员应该有一个字符串指针，一个有效元素个数变量，一个容量大小变量，一个npos变量(因为这是原本的string类中就有的)。为了方便起见，在设计阶段先将所有成员的访问权限均设置为public。同时将构造函数定义成全缺省函数。

        [1]构造函数一

            代码三：使用字符串构造对象

    1. //代码三
    2. #define _CRT_SECURE_NO_WARNINGS
    3. #include "iostream"
    4. using namespace std;
    5.  
    6. class String {
    7. public:
    8. 	char* Str;//字符串指针
    9. 	size_t Size;//有效元素个数
    10. 	size_t Capacity;//容量
    11. 	static size_t npos;
    12. public:
    13. 	String(const char* s = "") {
    14. 		//将指向空的指针指向空字符串
    15. 		if (s == nullptr)
    16. 			s = "";
    17. 		//注意要比申请比字符串长度多1的空间来存储 '\0'
    18. 		Str = new char[strlen(s) + 1];
    19. 		//将s指向的空间中的内容拷贝到Str指向的空间中，这个操作会把'\0'一并拷贝
    20. 		strcpy(Str, s);
    21. 		//更新有效元素个数和容量
    22. 		Size = strlen(s);
    23. 		Capacity = strlen(s);
    24. 	}
    25. };
    26.  
    27. size_t String::npos = -1;

        [2]构造函数二

            代码四：使用n个字符构造对象

    1. //代码四
    2. String(size_t n, char c) {
    3. 	//申请比有效元素多一个的空间
    4. 	Str = new char[n + 1];
    5.  
    6. 	//把n个c存入Str指向的空间中
    7. 	memset(Str, c, n);
    8.  
    9. 	//不要忘记设置'\0'
    10. 	Str[n] = '\0';
    11.  
    12. 	//更新有效元素和容量
    13. 	//容量要保持比有效元素个数多
    14. 	//用来存储'\0'
    15. 	Size = n;
    16. 	Capacity = n+1;
    17. }
    18.

      (2)析构函数 

            代码五：析构函数一定要检查字符串指针是否指向空，如果是空就不可以再释放了。

    1. //代码五
    2. ~String() {
    3. 	//如果指向空值，释放程序会崩溃的
    4. 	if (Str)
    5. 		delete[] Str;
    6. 	Str = nullptr;
    7. 	Size = 0;
    8. 	Capacity = 0;
    9. }

      (3)拷贝构造函数

            这里提供两种版本的拷贝构造函数以供参考。

        [1]传统版本

            代码六：传统版本是先释放指向的旧空间，构造新空间，然后使用strcpy函数拷贝数据。

            注意这样有个缺点，虽然概率很小。万一申请空间失败呢？那样就连原有的数据都没有了。

    1. //代码六
    2. String(const String& s) {
    3. 	//需要释放原本的空间
    4. 	if (Str) {
    5. 		delete[] Str;
    6. 	}
    7. 	Str = new char[strlen(s.Str) + 1];//+1是为了存储'\0'
    8. 	strcpy(Str, s.Str);
    9. 	Size = strlen(Str);
    10. 	Capacity = Size+1;//+1是因为申请空间时就申请了这么多
    11. }

        [2]简洁版本

            代码七： 简洁版本是先使用目标字符串构造一个临时对象，然后交换两个对象的字符串指针。这样做不但不用担心空间申请失败，也不用自己手动释放空间。当临时对象生命周期结束，系统会自动调用析构函数。

    1. //代码七
    2. String(const String& s) {
    3. 	String temp(s.Str);
    4. 	//交换temp.Str和this->Str指向的空间
    5. 	std::swap(Str, temp.Str);
    6. 	Size = strlen(Str);
    7. 	Capacity = Size+1;
    8. }

      (4)赋值运算符重载 

            赋值运算符重载也提供了两个版本以供参考。

        [1]传统版本

            代码八：传统版本需要考虑是不是对象自己给自己赋值，若是就直接返回。一定要记得开辟空间时，要比字符串长度大，这是为了存储'\0'

    1. //代码八
    2. String& operator=(const String& s) {
    3. 	//判断是否是自己给自己赋值
    4. 	if (this != &s) {
    5. 		String temp(Str);
    6. 		//记得释放原本指向的空间
    7. 		delete[] Str;
    8. 		Str = new char[strlen(s.Str) + 1];
    9. 		strcpy(Str, s.Str);
    10. 		Size = strlen(s.Str);
    11. 		Capacity = Size+1;
    12. 	}
    13. 	return *this;
    14. }

        [2]简洁版本

            代码九：简介版本不需要考虑自己给自己赋值，反正都是交换空间。

    1. //代码九
    2. String& operator=(const String& s) {
    3. 	String temp(s.Str);
    4. 	//交换空间
    5. 	std::swap(Str, temp.Str);
    6. 	Size = strlen(s.Str);
    7. 	Capacity = Size +1;
    8. 	return *this;
    9. }

    3.容量模块

      (1)有效字符函数 

            代码十：

    1. //代码十
    2. size_t SIZE() {
    3. 	return Size;
    4. }

      (2)有效字符函数

            代码十一： 

    1. //代码十一
    2. size_t CAPAcity() {
    3. 	return Capacity;
    4. }

      (3)扩容函数 

            代码十二：这里直接按照参数的两倍来扩容，记得需要释放原本的字符串空间。

    1. //代码十二
    2. void Reverse(size_t newCapacity) {
    3. 	//新容量大于旧容量
    4. 	if (newCapacity >= Capacity) {
    5. 		char* temp = new char[newCapacity *2];
    6. 		strcpy(temp, Str);
    7. 		delete[] Str;
    8. 		Str = temp;
    9. 		Capacity = 2 * newCapacity;
    10. 	}
    11. }

      (4)设置有效字符函数 

            代码十三：此函数机制为：新有效元素大于旧有效元素时可能需要扩容，继续判断，当新有效元素比容量还要大时需要扩容，扩容后使用memset函数添加元素。最后不要忘了手动加'\0'。

    1. //代码十三
    2. void Resize(size_t newSize, char c) {
    3. 	size_t oldSize = Size;
    4. 	size_t oldCapa = Capacity;
    5. 	//新的有效元素比旧的多
    6. 	if (newSize > oldSize) {
    7. 		//新元素比容量多 扩容
    8. 		if (newSize > oldCapa) {
    9. 			Reverse(newSize);
    10. 		}
    11. 		//往Str尾部插入合适数量的c
    12. 		memset(Str + Size, c, newSize - oldSize);
    13. 	}
    14. 	Size = newSize;
    15. 	Str[Size] = '\0';
    16. }

      (5)判空函数 

            代码十四：

    1. //代码十四
    2. bool Empty() {
    3. 	//容量等于0返回true
    4. 	return Size == 0;
    5. }

      (6)清空函数 

            代码十五：注意清空的含义是清空有效元素，不对容量进行操作。

    1. //代码十五
    2. void clear() {
    3. 	//只改变有效元素个数，不改变容量
    4. 	Size = 0;
    5. 	Str[0] = '\0';
    6. }

    4.迭代器模块

            其实迭代器就是当作指针使用的，为了和string迭代器形式相似，我们要用这条语句给指针起个小名：typedef char* Iterator;

      (1)正向迭代器

            代码十六：

    1. //代码十六
    2. typedef char* Iterator;
    3.  
    4. Iterator Begin() {
    5. 	return Str;
    6. }
    7.  
    8. Iterator End() {
    9. 	return Str + Size;
    10. }

      (2)反向迭代器

            代码十七：反向迭代器可以直接复用正向迭代器。 

    1. //代码十七
    2. typedef char* Iterator;
    3.  
    4. Iterator Rbegin() {
    5. 	return End();
    6. }
    7.  
    8. Iterator Rend() {
    9. 	return Begin();
    10. }

    5.访问模块

      (1)重载[]

            代码十八：注意一定要判断是否越界访问。同时也要多重载一份为const对象使用。使用assert来控制时要加头文件。#include

    1. //代码十八
    2. #include
    3.  
    4. char& operator[](size_t pos) {
    5. 	assert(pos < Size);
    6. 	return Str[pos];
    7. }
    8.  
    9. const char& operator[](size_t pos)const {
    10. 	assert(pos < Size);
    11. 	return Str[pos];
    12. }

      (2)重载cout<< 

            代码十九：注意<<不可以重载为成员函数，但我们还要使用私有变量，就把它设置为友元函数。至于为什么不可以重载为成员函数，我在《C++实现日期类》中已经总结了，感兴趣的可以去看看。

    1. //代码十九
    2. friend ostream& operator<<(ostream& _cout, const String& s) {
    3. 	_cout << s.Str;
    4. 	return _cout;
    5. }

    6.修改模块

      (1)尾插单个字符

            代码二十：尾插时需要注意扩容条件。

    1. //代码二十
    2. void Push_back(char c) {
    3. 	//满足条件说明空间已经存满了，因为那个1是用来存储'\0'的
    4. 	if (Size + 1== Capacity) {
    5. 		Reverse(Capacity);
    6. 	}
    7. 	Str[Size] = c;
    8. 	Str[Size+1] = '\0';
    9. 	Size++;
    10. }

      (2)重载+=

            代码二十一：+=有两种，+=字符串、+=对象。后者可以复用前者。这里要特别注意如何判断是否要扩容，当两个字符串有效元素加起来再加上'\0'的大小不比容量小时就应该扩容。

    1. //代码二十一
    2.  
    3. void operator+=(const char* s) {
    4. 	size_t oldSize = Size;
    5. 	//两个空间加起来元素个数
    6. 	size_t size = Size + strlen(s);
    7. 	//元素个数接近容量
    8. 	if (size+1 >= Capacity) {
    9. 		Reverse(size);
    10. 	}
    11. 	strcat(Str + oldSize, s);
    12. 	Size = size;
    13. }
    14.  
    15. //直接复用上面的
    16. String& operator+=(const String& s) {
    17. 	*this += s.Str;
    18. 	return *this;
    19. }

    7.特殊操作模块

      (1)转为C语言字符串类型

            代码二十二：

    1. //代码二十二
    2. const char* c_str()const
    3. {
    4. 	return Str;
    5. }

      (2)复制函数

            代码二十三：注意参数的调整问题。

    1. //代码二十三
    2. String Substr(size_t pos = 0, size_t n = npos) {
    3.     //没有传参
    4. 	if (n == npos)
    5. 		n = Size;
    6.  
    7.     //传递的参数个数大于有效元素个数就需要进行调整
    8. 	if (pos + n >= Size) {
    9. 		n =Size - pos;
    10. 	}
    11.  
    12. 	char* temp = new char[n + 1];
    13. 	strncpy(temp, Str + pos, n);
    14. 	temp[Size] = '\0';
    15.  
    16. 	String Stemp(temp);
    17. 	delete[] temp;
    18. 	return Stemp;
    19. }

      (3)正向查找函数

            代码二十四：注意没找到就返回npos。npos是-1。

    1. //代码二十四
    2. size_t Find(char c, size_t pos = 0) {
    3. 	for (int i = pos; i < Size; i++) {
    4. 		if (Str[i] == c)
    5. 			return i;
    6. 	}
    7. 	return npos;
    8. }

      (4)反向查找函数

            代码二十五：

    1. //代码二十五
    2. size_t Rfind(char c, size_t pos = npos) {
    3.  
    4.     //查找的开始位置越界就将位置定在结尾
    5. 	pos = pos < Size ? pos : Size;
    6.  
    7. 	for (int i = pos; i >= 0; i--) {
    8. 		if (Str[i] == c) {
    9. 			return i;
    10. 		}
    11. 	}
    12. 	return npos;
    13. }

    8.总体实现

            以下是String类的模拟实现，在运行程序发现不足之处的，可以在评论区留言。

    1. #define _CRT_SECURE_NO_WARNINGS //解决C语言函数报错
    2. #include "iostream"
    3. #include
    4. using namespace std;
    5.  
    6. class String {
    7. private:
    8. 	char* Str;//字符串指针
    9. 	size_t Size;//有效元素个数
    10. 	size_t Capacity;//容量
    11. 	static size_t npos;
    12. public:
    13. //构造模块
    14. /
    15. 	//构造函数1
    16. 	String(const char* s = "") {
    17. 		//将指向空的指针指向空字符串
    18. 		if (s == nullptr)
    19. 			s = "";
    20. 		//注意要比申请比字符串长度多1的空间来存储 '\0'
    21. 		Str = new char[strlen(s) + 1];
    22. 		//将s指向的空间中的内容拷贝到Str指向的空间中，这个操作会把'\0'一并拷贝
    23. 		strcpy(Str, s);
    24. 		//更新有效元素个数和容量
    25. 		Size = strlen(s);
    26. 		Capacity = strlen(s)+1;
    27. 	}
    28. 	//构造函数2
    29. 	String(size_t n, char c) {
    30. 		//申请比有效元素多一个的空间
    31. 		Str = new char[n + 1];
    32. 		//把n个c存入Str指向的空间中
    33. 		memset(Str, c, n);
    34. 		//不要忘记设置'\0'
    35. 		Str[n] = '\0';
    36. 		//更新有效元素和容量
    37. 		//容量要保持比有效元素个数多
    38. 		//用来存储'\0'
    39. 		Size = n;
    40. 		Capacity = n+1;
    41. 	}
    42. 	//析构函数
    43. 	~String() {
    44. 		//如果指向空值，释放程序会崩溃的
    45. 		if (Str)
    46. 			delete[] Str;
    47. 		Str = nullptr;
    48. 		Size = 0;
    49. 		Capacity = 0;
    50. 	}
    51.  
    52. 	//传统版拷贝构造
    53. 	/*
    54. 	String(const String& s) {
    55. 		//需要释放原本的空间
    56. 		if (Str) {
    57. 			delete[] Str;
    58. 		}
    59. 		Str = new char[strlen(s.Str) + 1];
    60. 		strcpy(Str, s.Str);
    61. 		Size = strlen(Str);
    62. 		Capacity = Size+1;
    63. 	}
    64. 	*/
    65. 	//简洁版拷贝构造
    66. 	String(const String& s) {
    67. 		String temp(s.Str);
    68. 		//交换temp.Str和this->Str指向的空间
    69. 		std::swap(Str, temp.Str);
    70. 		Size = strlen(Str);
    71. 		Capacity = Size+1;
    72. 	}
    73.  
    74. 	//传统版赋值运算符重载
    75. 	/*
    76. 	String& operator=(const String& s) {
    77. 		//判断是否是自己给自己赋值
    78. 		if (this != &s) {
    79. 			String temp(Str);
    80. 			//记得释放原本指向的空间
    81. 			delete[] Str;
    82. 			Str = new char[strlen(s.Str) + 1];
    83. 			strcpy(Str, s.Str);
    84. 			Size = strlen(s.Str);
    85. 			Capacity = Size + 1;
    86. 		}
    87. 		return *this;
    88. 	}
    89. 	*/
    90.  
    91. 	//简洁版赋值运算符重载
    92. 	String& operator=(const String& s) {
    93. 		String temp(s.Str);
    94. 		//交换空间
    95. 		std::swap(Str, temp.Str);
    96. 		Size = strlen(s.Str);
    97. 		Capacity = Size +1;
    98. 		return *this;
    99. 	}
    100.  
    101. //容量模块
    102. /
    103. 	//有效元素
    104. 	size_t SIZE() {
    105. 		return Size;
    106. 	}
    107.  
    108. 	//容量
    109. 	size_t CAPAcity() {
    110. 		return Capacity;
    111. 	}
    112.  
    113. 	//扩容函数
    114. 	void Reverse(size_t newCapacity) {
    115. 		//新容量大于旧容量
    116. 		if (newCapacity >= Capacity) {
    117. 			char* temp = new char[newCapacity *2];
    118. 			strcpy(temp, Str);
    119. 			delete[] Str;
    120. 			Str = temp;
    121. 			Capacity = 2 * newCapacity;
    122. 		}
    123. 	}
    124.  
    125. 	//设置有效元素
    126. 	void Resize(size_t newSize, char c) {
    127. 		size_t oldSize = Size;
    128. 		size_t oldCapa = Capacity;
    129. 		//新的有效元素比旧的多
    130. 		if (newSize > oldSize) {
    131. 			//新元素比容量多 扩容
    132. 			if (newSize > oldCapa) {
    133. 				Reverse(newSize);
    134. 			}
    135. 			//往Str尾部插入合适数量的c
    136. 			memset(Str + Size, c, newSize - oldSize);
    137. 		}
    138. 		Size = newSize;
    139. 		Str[Size] = '\0';
    140. 	}
    141.  
    142. 	//判空函数
    143. 	bool Empty() {
    144. 		//容量等于0返回true
    145. 		return Size == 0;
    146. 	}
    147.  
    148. 	//清空函数
    149. 	void clear() {
    150. 		//只改变有效元素个数，不改变容量
    151. 		Size = 0;
    152. 		Str[0] = '\0';
    153. 	}
    154. //迭代器模块
    155. /
    156. 	typedef char* Iterator;
    157. 	//获取正向首指针
    158. 	Iterator Begin() {
    159. 		return Str;
    160. 	}
    161.  
    162. 	//获取正向尾指针
    163. 	Iterator End() {
    164. 		return Str + Size;
    165. 	}
    166. 	typedef char* Iterator;
    167. 	//获取反向首指针
    168. 	Iterator Rbegin() {
    169. 		return End();
    170. 	}
    171.  
    172. 	//获取反向尾指针
    173. 	Iterator Rend() {
    174. 		return Begin();
    175. 	}
    176. //访问模块
    177. /
    178. 	//普通[]重载
    179. 	char& operator[](size_t pos) {
    180. 		assert(pos < Size);
    181. 		return Str[pos];
    182. 	}
    183. 	//const[]重载
    184. 	const char& operator[](size_t pos)const {
    185. 		assert(pos < Size);
    186. 		return Str[pos];
    187. 	}
    188. 	// <<重载
    189. 	friend ostream& operator<<(ostream& _cout, const String& s) {
    190. 		_cout << s.Str;
    191. 		return _cout;
    192. 	}
    193. //访问模块
    194. /
    195. 	//尾插
    196. 	void Push_back(char c) {
    197. 		//满足条件说明空间已经存满了，因为那个1是用来存储'\0'的
    198. 		if (Size + 1== Capacity) {
    199. 			Reverse(Capacity);
    200. 		}
    201. 		Str[Size] = c;
    202. 		Str[Size+1] = '\0';
    203. 		Size++;
    204. 	}
    205. 	//+=重载
    206. 	void operator+=(const char* s) {
    207. 		size_t oldSize = Size;
    208. 		//两个空间加起来元素个数
    209. 		size_t size = Size + strlen(s);
    210. 		//元素个数接近容量
    211. 		if (size+1 >= Capacity) {
    212. 			Reverse(size);
    213. 		}
    214. 		strcat(Str + oldSize, s);
    215. 		Size = size;
    216. 	}
    217. 	//+=重载
    218. 	String& operator+=(const String& s) {
    219. 		*this += s.Str;
    220. 		return *this;
    221. 	}
    222. //特殊操作模块
    223. /
    224. 	//转换C语言字符串
    225. 	const char* c_str()const
    226. 	{
    227. 		return Str;
    228. 	}
    229.  
    230. 	//复制
    231. 	String Substr(size_t pos = 0, size_t n = npos) {
    232. 		if (n == npos)
    233. 			n = Size;
    234. 		if (pos + n >= Size) {
    235. 			n =Size - pos;
    236. 		}
    237. 		char* temp = new char[n + 1];
    238. 		strncpy(temp, Str + pos, n);
    239. 		temp[Size] = '\0';
    240.  
    241. 		String Stemp(temp);
    242. 		delete[] temp;
    243. 		return Stemp;
    244. 	}
    245. 	//正向查找
    246. 	size_t Find(char c, size_t pos = 0) {
    247. 		for (int i = pos; i < Size; i++) {
    248. 			if (Str[i] == c)
    249. 				return i;
    250. 		}
    251. 		return npos;
    252. 	}
    253. 	//反向查找
    254. 	size_t Rfind(char c, size_t pos = npos) {
    255. 		pos = pos < Size ? pos : Size;
    256. 		for (int i = pos; i >= 0; i--) {
    257. 			if (Str[i] == c) {
    258. 				return i;
    259. 			}
    260. 		}
    261. 		return npos;
    262. 	}
    263. };
    264.  
    265. size_t String::npos = -1;
    266.  
    267. int main() {
    268. 	const char* sp = "abc12345566743212343455655";
    269. 	String s1(sp);
    270. 	String s2 = s1;
    271. 	auto it = s2.Begin();
    272. 	while (it != s2.End()) {
    273. 		cout << *it << " ";
    274. 		it++;
    275. 	}
    276. }

  • 相关阅读:
    MIPI CSI-2笔记（8） -- Low Level Protocol（同步短包的数据类型编码）
    MySQL8--Windows下使用压缩包安装的方法
    .Net 6.0全局异常捕获
    STM8的C语言编程（6）－－8位定时器应用之二
    Uniapp 实现全民分销功能
    拷贝控制操作
    indexDB & localForage
    主存储器与CPU的连接
    遨博机械臂URDF功能包ROS仿真
    openstack nova 源码分析
  • 原文地址：https://blog.csdn.net/weixin_57761086/article/details/126560762