devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ STL --- string类模拟实现_cpp中string的模拟实现中的strlen

作者：2023面试高手 | 2024-04-08 21:33:04

赞

踩

cpp中string的模拟实现中的strlen

目录

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 <string.h>
  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 <string.h>
  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<assert.h>

  1. //代码十八
  2. #include<assert.h>
  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<assert.h>
  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. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/388343
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号