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

C/C++ 字符串拷贝处理_c++字符串拷贝

作者：Cpp五条 | 2024-05-13 10:16:18

赞

踩

c++字符串拷贝

C语言的字符串操作

strtok 实现字符串切割: 将字符串根据分隔符进行切割分片.

  1. #include <stdio.h>
  2.  
  3. int main(int argc, char* argv[])
  4. {
  5. 	char str[] = "hello,lyshark,welcome";
  6. 	char *ptr;
  7.  
  8. 	ptr = strtok(str, ",");
  9. 	while (ptr != NULL)
  10. 	{
  11. 		printf("切割元素: %s\n", ptr);
  12. 		ptr = strtok(NULL, ",");
  13. 	}
  14. 	system("pause");
  15. 	return 0;
  16. }

strlen 获取字符串长度:

  1. #include <stdio.h>
  2.  
  3. int main(int argc, char* argv[])
  4. {
  5. 	char Array[] = "\0hello\nlyshark";
  6. 	char Str[] = { 'h', 'e', 'l', 'l', 'o' };
  7.  
  8. 	int array_len = strlen(Array);
  9. 	printf("字符串的有效长度：%d\n", array_len);
  10. 	int str_len = strlen(Str);
  11. 	printf("字符串数组有效长度: %d\n", str_len);
  12. 	
  13. 	int index = 0;
  14. 	while (Str[index] != '\0')
  15. 	{
  16. 		index++;
  17. 		printf("Str数组元素: %c --> 计数: %d \n", Str[index], index);
  18. 	}
  19.  
  20. 	system("pause");
  21. 	return 0;
  22. }

strcpy 字符串拷贝:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. int main(int argc, char* argv[])
  6. {
  7. 	char Array[] = "hello lyshark";
  8. 	char tmp[100];
  9.  
  10. 	// 学习strcpy函数的使用方式
  11. 	if (strcpy(tmp, Array) == NULL)
  12. 		printf("从Array拷贝到tmp失败\n");
  13. 	else
  14. 		printf("拷贝后打印: %s\n", tmp);
  15.  
  16. 	// 清空tmp数组的两种方式
  17. 	for (unsigned int x = 0; x < strlen(tmp); x++)
  18. 		tmp[x] = ' ';
  19.  
  20. 	memset(tmp, 0, sizeof(tmp));
  21. 	
  22. 	// 学习strncpy函数的使用方式
  23. 	if (strncpy(tmp, Array, 3) == NULL)
  24. 		printf("从Array拷贝3个字符到tmp失败\n");
  25. 	else
  26. 		printf("拷贝后打印: %s\n", tmp);
  27.  
  28. 	system("pause");
  29. 	return 0;
  30. }

strcat字符串连接: 将由src指向的空终止字节串的副本追加到由dest指向的以空字节终止的字节串的末尾

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. int main(int argc, char* argv[])
  6. {
  7. 	char str1[50] = "hello ";
  8. 	char str2[50] = "lyshark!";
  9.  
  10. 	char * str = strcat(str1, str2);
  11. 	printf("字符串连接: %s \n", str);
  12.  
  13. 	str = strcat(str1, " world");
  14. 	printf("字符串连接: %s \n", str);
  15.  
  16. 	str = strncat(str1, str2, 3);
  17. 	printf("字符串连接: %s \n", str);
  18.  
  19. 	system("pause");
  20. 	return 0;
  21. }

strcmp 字符串对比:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. int Str_Cmp(const char * lhs, const char * rhs)
  6. {
  7. 	int ret = strcmp(lhs, rhs);
  8. 	if (ret == 0)
  9. 		return 1;
  10. 	else
  11. 		return 0;
  12. }
  13.  
  14. int main(int argc, char* argv[])
  15. {
  16. 	char *str1 = "hello lyshark";
  17. 	char *str2 = "hello lyshark";
  18.  
  19. 	int ret = Str_Cmp(str1, str2);
  20. 	printf("字符串是否相等: %d \n", ret);
  21.  
  22. 	if (!strncmp(str1, str2, 3))
  23. 		printf("两个字符串,前三位相等");
  24.  
  25. 	system("pause");
  26. 	return 0;
  27. }

strshr 字符串截取:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. int main(int argc, char* argv[])
  6. {
  7. 	const char str[] = "hello ! lyshark";
  8. 	char *ret;
  9.  
  10. 	ret = strchr(str, '!');
  11. 	printf("%s \n", ret);
  12.  
  13. 	system("pause");
  14. 	return 0;
  15. }

字符串逆序排列:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. void Swap_Str(char *Array)
  6. {
  7. 	int len = strlen(Array);
  8. 	char *p1 = Array;
  9. 	char *p2 = &Array[len - 1];
  10. 	while (p1 < p2)
  11. 	{
  12. 		char tmp = *p1;
  13. 		*p1 = *p2;
  14. 		*p2 = tmp;
  15. 		p1++, p2--;
  16. 	}
  17. }
  18.  
  19. int main(int argc, char* argv[])
  20. {
  21. 	char str[20] = "hello lyshark";
  22. 	Swap_Str(str);
  23. 	
  24. 	for (int x = 0; x < strlen(str); x++)
  25. 		printf("%c", str[x]);
  26.  
  27. 	system("pause");
  28. 	return 0;
  29. }

实现字符串拷贝:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. // 使用数组实现字符串拷贝
  6. void CopyString(char *dest,const char *source)
  7. {
  8. 	int len = strlen(source);
  9. 	for (int x = 0; x < len; x++)
  10. 	{
  11. 		dest[x] = source[x];
  12. 	}
  13. 	dest[len] = '\0';
  14. }
  15.  
  16. // 使用指针的方式实现拷贝
  17. void CopyStringPtr(char *dest, const char *source)
  18. {
  19. 	while (*source != '\0')
  20. 	{
  21. 		*dest = *source;
  22. 		++dest, ++source;
  23. 	}
  24. 	*dest = '\0';
  25. }
  26. // 简易版字符串拷贝
  27. void CopyStringPtrBase(char *dest, const char *source)
  28. {
  29. 	while (*dest++ = *source++);
  30. }
  31.  
  32. int main(int argc, char* argv[])
  33. {
  34. 	char * str = "hello lyshark";
  35. 	char buf[1024] = { 0 };
  36. 	CopyStringPtrBase(buf, str);
  37. 	printf("%s \n", buf);
  38.  
  39. 	system("pause");
  40. 	return 0;
  41. }

格式化字符串:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. int main(int argc, char* argv[])
  6. {
  7. 	// 格式化填充输出
  8. 	char buf[30] = { 0 };
  9. 	sprintf(buf, "hello %s %s", "lyshark","you are good");
  10. 	printf("格式化后: %s \n", buf);
  11.  
  12. 	// 拼接字符串
  13. 	char *s1 = "hello";
  14. 	char *s2 = "lyshark";
  15. 	memset(buf, 0, 30);
  16. 	sprintf(buf, "%s --> %s", s1, s2);
  17. 	printf("格式化后: %s \n", buf);
  18.  
  19. 	// 数字装换位字符串
  20. 	int number = 100;
  21. 	memset(buf, 0, 30);
  22. 	sprintf(buf, "%d", number);
  23. 	printf("格式化后: %s \n", buf);
  24.  
  25. 	system("pause");
  26. 	return 0;
  27. }

动态存储字符串:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. int main(int argc, char* argv[])
  6. {
  7. 	// 分配空间
  8. 	char **p = malloc(sizeof(char *)* 5);
  9. 	for (int x = 0; x < 5;++x)
  10. 	{
  11. 		p[x] = malloc(64); 
  12. 		memset(p[x], 0, 64);
  13. 		sprintf(p[x], "Name %d", x + 1);
  14. 	}
  15.  
  16. 	// 打印字符串
  17. 	for (int x = 0; x < 5; x++)
  18. 		printf("%s \n", p[x]);
  19.  
  20. 	// 释放空间
  21. 	for (int x = 0; x < 5; x++)
  22. 	{
  23. 		if (p[x] != NULL)
  24. 			free(p[x]);
  25. 	}
  26.  
  27. 	system("pause");
  28. 	return 0;
  29. }

字符串拼接:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. char * StringSplicing(char *String1, char  *String2)
  6. {
  7. 	char Buffer[1024];
  8.  
  9. 	int index = 0;
  10. 	int len = strlen(String1);
  11. 	while (String1[index] != '\0')
  12. 	{
  13. 		Buffer[index] = String1[index];
  14. 		index++;
  15. 	}
  16. 	while (String2[index - len] != '\0')
  17. 	{
  18. 		Buffer[index] = String2[index - len];
  19. 		index++;
  20. 	}
  21. 	Buffer[index] = '\0';
  22.  
  23. 	char *ret = (char*)calloc(1024, sizeof(char*));
  24. 	if (ret)
  25. 		strcpy(ret, Buffer);
  26. 	return ret;
  27. }
  28.  
  29. int main(int argc, char* argv[])
  30. {
  31. 	char *str1 = "hello ";
  32. 	char *str2 = "lyshark ! \n";
  33.  
  34. 	char * new_str = StringSplicing(str1, str2);
  35. 	printf("拼接好的字符串是: %s", new_str);
  36.  
  37. 	system("pause");
  38. 	return 0;
  39. }

实现strchr:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. char * MyStrchr(const char *String, char ch)
  6. {
  7. 	char *ptr = String;
  8. 	while (*ptr != '\0')
  9. 	{
  10. 		if (*ptr == ch)
  11. 			return ptr;
  12. 		ptr++;
  13. 	}
  14. 	return NULL;
  15. }
  16.  
  17. int main(int argc, char* argv[])
  18. {
  19. 	char Str[] = "hello lyshark";
  20. 	char ch = 's';
  21.  
  22. 	char *ptr = MyStrchr(Str, ch);
  23. 	printf("输出结果: %s \n", ptr);
  24.  
  25. 	system("pause");
  26. 	return 0;
  27. }

自己实现寻找字符串子串:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. // 查找子串第一次出现的位置
  5. char *MyStrStr(const char* str, const char* substr)
  6. {
  7. 	const char *mystr = str;
  8. 	const char *mysub = substr;
  9.  
  10. 	while (*mystr != '\0')
  11. 	{
  12. 		if (*mystr != *mysub)
  13. 		{
  14. 			++mystr;
  15. 			continue;
  16. 		}
  17.  
  18. 		char *tmp_mystr = mystr;
  19. 		char *tmp_mysub = mysub;
  20.  
  21. 		while (tmp_mysub != '\0')
  22. 		{
  23. 			if (*tmp_mystr != *tmp_mysub)
  24. 			{
  25. 				++mystr;
  26. 				break;
  27. 			}
  28. 			 ++tmp_mysub;
  29. 		}
  30.  
  31.  
  32. 		if (*tmp_mysub == '\0')
  33. 		{
  34. 			return mystr;
  35. 		}
  36. 	}
  37. 	return NULL;
  38. }
  39.  
  40. int main(int argc, char* argv[])
  41. {
  42.  
  43. 	char *str = "abcdefg";
  44. 	char *sub = "fg";
  45.  
  46. 	char * aaa = MyStrStr(str, sub);
  47.  
  48. 	printf("%s", aaa);
  49.  
  50. 	system("pause");
  51. 	return 0;
  52. }

删除字符串中连续字符

  1. #include <stdio.h>
  2. char del(char s[],int pos,int len)   //自定义删除函数，这里采用覆盖方法
  3.  {
  4.    int i;
  5.    for (i=pos+len-1; s[i]!='\0'; i++,pos++)
  6.      s[pos-1]=s[i];   //用删除部分后的字符依次从删除部分开始覆盖
  7.    s[pos-1]='\0';
  8.    return s;
  9.  }
  10. int main(int argc, char *argv[])
  11. {
  12.   char str[50];
  13.   int position,length;
  14.   printf ("please input string:\n");
  15.   gets(str);   //使用gets函数获得字符串
  16.   printf ("please input delete position:");
  17.   scanf("%d",&position);
  18.   printf ("please input delete length:");
  19.   scanf("%d",&length);
  20.   del(str,position,length);
  21.   printf ("the final string:%s\n",str);
  22.   return 0;
  23. }

C++的字符串操作

在C语言中想要输出数据需要使用Printf来实现,但C++中引入了另一种输出方式,C++中形象的将此过程称为流,数据的输入输出是指由若干个字节组成的字节序列,这些序列从一个对象中传递到另一个对象,我们将此过程形象的表示为数据的流,数据流可以包括ASCII字符,二进制数据,图形图像数据,音频数据等,流都将可以操作.

字符串类的初始化:

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4.  
  5. int main(int argc, char* argv[])
  6. {
  7. 	string str("hello lyshark"); // 定义一个字符串
  8.  
  9. 	string str_1(str);           // 构造函数,将 str中的内容全部复制到str_1
  10. 	cout << str_1 << endl;
  11. 	string str_2(str, 2, 5);     // 构造函数,从字符串str的第2个元素开始,复制5个元素,赋值给str_2
  12. 	cout << str_2 << endl;
  13. 	string str_3(str.begin(), str.end()); // 复制字符串 str 的所有元素，并赋值给 str_3
  14. 	cout << str_3 << endl;
  15.  
  16. 	char ch[] = "lyshark";
  17. 	string str_4(ch, 3);    // 将字符串ch的前5个元素赋值给str_4
  18. 	cout << str_4 << endl;
  19.  
  20. 	string str_5(5, 'x');   // 将 5 个 'X' 组成的字符串 "XXXXX" 赋值给 str_5
  21. 	cout << str_5 << endl;
  22. 	
  23. 	system("pause");
  24. 	return 0;
  25. }

标准输出流: 首先我们演示标准的输入输出,其需要引入头文件<iostream>

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <iostream>
  3.  
  4. using namespace std;
  5.  
  6. int main(int argc, char* argv[])
  7. {
  8. 	char str[] = "lyshark";
  9. 	int number = 0;
  10.  
  11. 	cout << "hello: " << str << endl;
  12. 	cin >> number;
  13. 	if (number == 0)
  14. 	{
  15. 		cerr << "Error msg" << endl;  // 标准的错误流
  16. 		clog << "Error log" << endl;  // 标准的日志流
  17. 	}
  18.  
  19. 	int x, y;
  20. 	cin >> x >> y;                      // 一次可以接受两个参数
  21. 	freopen("./test.log", "w", stdout); // 将标准输出重定向到文件
  22.  
  23. 	system("pause");
  24. 	return 0;
  25. }

格式化输出: 在程序中一般用cout和插入运算符“<<”实现输出，cout流在内存中有相应的缓冲区。

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <iostream>
  3. #include <iomanip>
  4.  
  5. using namespace std;
  6.  
  7. int main(int argc, char* argv[])
  8. {
  9. 	cout << hex << 100 << endl;             // 十六进制输出
  10. 	cout << dec << 100 << endl;             // 十进制输出
  11. 	cout << oct << 100 << endl;             // 八进制输出
  12. 	cout << fixed << 10.053 << endl;        // 单浮点数输出
  13. 	cout << scientific << 10.053 << endl;   // 科学计数法
  14.  
  15. 	cout << setw(10) << "hello" << setw(10) << "lyshark" << endl;  // 默认两个单词之间空格
  16.  
  17. 	cout << setfill('-') << setw(10) << "hello" << endl; // 指定域宽,输出字符串,空白处以'-'填充
  18.  
  19. 	for (int x = 0; x < 3; x++)
  20. 	{
  21. 		cout << setw(10) << left << "hello" ; // 自动(left/right)对齐,不足补空格
  22. 	}
  23.  
  24. 	cout << endl;
  25. 	system("pause");
  26. 	return 0;
  27. }

单个字符输出: 流对象中,提供了专用于输出单个字符的成员函数put

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <iostream>
  3. #include <iomanip>
  4.  
  5. using namespace std;
  6.  
  7. int main(int argc, char* argv[])
  8. {
  9. 	char *str = "lyshark";
  10.  
  11. 	for (int x = 6; x >= 0; x--)
  12. 		cout.put(*(str + x));  // 每次输出一个字符
  13. 	cout.put('\n');
  14.  
  15. 	system("pause");
  16. 	return 0;
  17. }

标准输入流: 通过测试cin的真值,判断流对象是否处于正常状态.

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <iostream>
  3. #include <iomanip>
  4.  
  5. using namespace std;
  6.  
  7. int main(int argc, char* argv[])
  8. {
  9. 	float grade;
  10.  
  11. 	while (cin >> grade)
  12. 	{
  13. 		if (grade >= 85)
  14. 			cout << grade << " good" << endl;
  15. 	}
  16. 	system("pause");
  17. 	return 0;
  18. }

读取字符串: getline函数的作用是从输入流中读取一行字符

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <iostream>
  3. #include <iomanip>
  4.  
  5. using namespace std;
  6.  
  7. int main(int argc, char* argv[])
  8. {
  9. 	char str[20];
  10. 	int x, y, z;
  11.  
  12. 	cin >> x >> y >> z;
  13. 	cout << x << y << z;
  14.  
  15. 	cin.getline(str, 20);        // 读入字符遇到\n结束读取
  16. 	cout << str << endl;
  17.  
  18. 	cin.getline(str, 20, 'z');  // 读入字符遇到z字符才结束
  19. 	cout << str << endl;
  20.  
  21. 	system("pause");
  22. 	return 0;
  23. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/563114
推荐阅读
相关标签

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

  

闽ICP备14008679号