字符串的封装

最新推荐文章于 2022-12-27 08:59:28 发布
最新推荐文章于 2022-12-27 08:59:28 发布
阅读量4.9k 收藏 6
点赞数 2
分类专栏： C/C++ 文章标签： C语言 字符串 封装 实现库函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jobbofhe/article/details/51262280
版权 
//编译环境VS2013

strStr.h
#define  _CRT_SECURE_NO_WARNINGS

//字符串封装，需要库函数
//不需要库函数，我现在完成的就是自己实现库函数

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct CString
{
	char *p;<span style="white-space:pre">	</span>//保存字符串首地址
	int realLength;<span style="white-space:pre">	</span>//实际长度
};
typedef struct CString myString; //全局变量


//主要实现的功能概述如下：
//字符串，初始化，打印，
//查找，查找字符，查找字符串
//尾部增加，（字符，字符串）
//删除（字符，字符串），
//任意位置增加（字符，字符串）
//修改字符串，（字符，字符串替换）


void initStr(myString *string); <span style="white-space:pre">			</span>//原封不动初始化
void initWithLength(myString *string, int length);<span style="white-space:pre">	</span>//开辟长度，内存清零
void initWithString(myString *string, char *copyString);//初始化，并拷贝字符串
void printStr(myString *string); //打印
void backAddChar(myString *string, char *ch);<span style="white-space:pre">		</span> //尾部插入字符
void backAddString(myString *string, char *str);<span style="white-space:pre">	</span>//尾部掺入字符串
void run(myString *string);
//以下两个查找函数 ，仅仅是找到了第一个匹配的字符，还要完成所有匹配的字符
//完成这个工作仅仅需要续断循环查找即可
char *findFirstChar(myString *string, char ch);<span style="white-space:pre">		</span>//返回第一个匹配的字符
char *findFirstString(myString *string, char str);
int deleteFirstChar(myString *string, char ch);
int deleteFirstString(myString *string, char *str);

void addChar(myString *string, char *ch, char *pos);<span style="white-space:pre">	</span> //任意位置增加字符
void addString(myString *string, char *str, char *pos);<span style="white-space:pre">	</span>//任意位置增加字符串

void changeFirstChar(myString *string, const char oldChar, const newChar);
void changeFirstString(myString *string, char * const oldString, char *const newString);


//strStr.c  主要函数文件

#include"strStr.h"

int myStrLen(char *p) //strlen()
{
	if (p == NULL)
	{
		return -1; //失败
	}
	int length = 0;
	while (*p != '\0')
	{
		length++;
		p++;
	}
	return length;
}

//完全可以替代strcpy函数。
char *myStrcpy(char *dest, const char *source) //限制拷贝的时候修改内容
{
	if (dest == NULL || source == NULL)
	{
		return NULL;
	}
	char *destback = dest;
	while (*source != '\0')
	{
		*dest = *source; //赋值

		source++;
		dest++;//指针不断向前
	}
	*dest = '\0';
	return destback;
}
char *myStrcat(char *dest, const char *source)
{
	if (dest == NULL || source == NULL)
	{
		return NULL;
	}
	else
	{
		char *destbak = dest; //保留dest的地址
		while (*dest != '\0')
		{
			dest++;//指针移动，直到\0
		}
		while (*source != '\0')
		{
			*dest = *source;
			dest++;
			source++;
		}
		*dest = '\0';
		return destbak;
	}
}
char *myStrchr(const char *dest, const char ch) //找寻一个字符
{
	if (dest == NULL)
	{
		return NULL;
	}
	while (*dest != '\0')
	{
		if (*dest == ch)
		{
			return dest;//找到ch，返回地址
		}
		dest++;
	}
	return NULL; //找到最后都没有找到
}

char *myStrstr(const char * const dest, const char * const findStr)
{
	if (dest == NULL || findStr == NULL)
	{
		return NULL;
	}

	char *destbak = dest;//备份dest
	char *p = NULL; //保存找到的地址

	while (*destbak != '\0')
	{
		int flag = 1;//假设相等
		char *findStrbak = findStr; //备份findStr;
		char *nowdestbak = destbak;

		while (*findStrbak != '\0')
		{
			if (*nowdestbak != '\0')//判断被查找字符串是否结束
			{
				//有一个不相等，就不相等
				if (*findStrbak != *nowdestbak)
				{
					flag = 0;//不相等
				}
				nowdestbak++;
				findStrbak++;
			}
			else
			{
				flag = 0; //设置标识
				break;
			}
		}
		if (flag == 1)//找到了
		{
			p = destbak;//找到位置首地址
			return p; //返回找到的字符串的地址。
		}
		destbak++;
	}
	return NULL; //遍历完成之后没有任何效果则返回空。
}



void initStr(myString *string) //原封不动初始化
{
	string->p = NULL;
	string->realLength = 0;
}
void initWithLength(myString *string, int length)//开辟长度，内存清零
{
	//string->p = (char *)malloc(sizeof(char)*length);//分配内存不清零
	string->p = (char *)calloc(length, sizeof(char));//分配内存并清零
	string->realLength = length;
}
void initWithString(myString *string, char *copyString)//初始化，并拷贝字符串
{
	int length = strlen(copyString);//获取字符串长度
	string->p = (char *)calloc(length + 1, sizeof(char));
	myStrcpy(string->p, copyString);//拷贝字符串
	//这里不需要考虑末尾字符串为\0的问题，因为一开始就全清零了
	string->realLength = length + 1; //设置字符串长度
}
void backAddChar(myString *string, char *ch) //尾部插入字符
{
	//strlen()函数不会计算\0.
	if (strlen(string->p) + 1 == string->realLength)//意味着满了
	{
		//重新分配内存
		string->p = realloc(string->p, string->realLength + 1);
		string->realLength += 1;
		string->p[string->realLength - 2] = ch;
		string->p[string->realLength - 1] = '\0';
		//末尾加0 结束
	}
	else
	{
		int nowLength = myStrLen(string->p);
		string->p[nowLength] = ch;
		string->p[nowLength + 1] = '\0';
	}
	
}
void backAddString(myString *string, char *str)//尾部掺入字符串
{
	int nowmyStringLength = myStrLen(string->p);//获取当前长度
	int addStringLength = myStrLen(str);//要增加的长度

	//如果 当前长度+要增加的长度+'\0'的长度 大于 原来字符串额实际长度
	if (nowmyStringLength + addStringLength + 1 > string->realLength)
	{
		//判断是否越界
		int needAddLength = nowmyStringLength + addStringLength + 1 - (string->realLength);
		//需要增加的程度等于将要加入的字符串程长度+1
		string->p = (char *)realloc(string->p, string->realLength + needAddLength);
		myStrcat(string->p, str);
		string->realLength += needAddLength; //改变字符串实际长度
	}
	else
	{
		myStrcat(string->p, str);
	}
}

void printStr(myString *string) //打印
{
	printf("\n string=%s", string->p);
}

void run(myString *string)
{
	system(string->p);
}

char *findFirstChar(myString *string, char ch)
{
	char *p = myStrchr(string->p, ch);
	return p;
}
char *findFirstString(myString *string, char *str)
{
	char *pres = myStrstr(string->p, str);
	return pres;
}

int deleteFirstChar(myString *string, const char ch)
{
	char *p = myStrchr(string->p, ch);//查找
	if (p == NULL)
	{
		return 0;
	}
	else
	{
		char *pnext = p + 1;
		while (*pnext != '\0')
		{
			*p = *pnext;
			p++;
			pnext++;//删除的元素后面的每一个元素都前移一位
		}
		*p = '\0';
		return 1;
		//一开始我有一个问题就是，当pnext='\0'.也就是整个dest中
		//只有一个字符，且这个字符刚好是要删除的字符，那么while (*pnext != '\0')
		//
	}
}
int deleteFirstString(myString *string, char * const str)
{
	char *pres = myStrstr(string->p, str);
	if (pres == NULL)
	{
		return 0;//删除失败
	}
	else
	{
		int length = myStrLen(str); //求字符串长度
		char *pnext = pres + length; //下一个字符串
		while (*pnext != '\0')
		{
			*pres = *pnext; //将从pres到pres+length长度之间的字符串删除
			pres++;
			pnext++;
		}
		*pres = '\0';
		return 1; //删除成功
	}
}

void addChar(myString *string, char *ch, char *pos) //任意位置增加字符
{
	if (pos == NULL || string == NULL)
	{
		return;
	}
	if (myStrLen(string->p) + 1 == string->realLength)//意味着满了
	{
		//空间满了之后需要重新申请内存
		string->p = (char *)realloc(string->p, string->realLength + 1);
		//申请了内存之后，字符的实际长度就加1
		string->realLength += 1;
		//实际长度增加了之后开始移动，把要插入的位置腾出来

		int nowLength = myStrLen(string->p);//求出当前总长度
		int moveLength = myStrLen(pos);//要移动的长度，从插入位置pos一直到结尾

		for (int i = nowLength; i > nowLength - moveLength; i--)
		{
			string->p[i] = string->p[i - 1];//后移一位

		}
		//移动完成之后，插入位置腾出来了，现在插入字符
		string->p[nowLength - moveLength] = ch;//插入
		//插入之后将字符处啊末尾加上'\0'
		string->p[nowLength + 1] = '\0';
	}
	else //没有满的情况，也就是不用申请内存
	{
		int nowLength = myStrLen(string->p);//求出当前总长度
		int moveLength = myStrLen(pos);//要移动的长度，从插入位置pos一直到结尾

		for (int i = nowLength; i > nowLength - moveLength; i--)
		{
			string->p[i] = string->p[i - 1];//后移一位

		}
		//移动完成之后，插入位置腾出来了，现在插入字符
		string->p[nowLength - moveLength] = ch;//插入
		//插入之后将字符处啊末尾加上'\0'
		string->p[nowLength + 1] = '\0';
	}
}

void addString(myString *string, char *str, char *pos)//任意位置增加字符串
{
	if (pos == NULL || string == NULL)
	{
		return;
	}

	int nowmyStringLength = myStrLen(string->p);//获取当前长度
	int addStringLength = myStrLen(str);//要增加的长度

	//如果 当前长度+要增加的长度+'\0'的长度 大于 原来字符串额实际长度
	if (nowmyStringLength + addStringLength + 1 > string->realLength)
	{
		//判断是否越界
		int needAddLength = nowmyStringLength + addStringLength + 1 - (string->realLength);
		//需要增加的程度等于将要加入的字符串程长度+1
		string->p = (char *)realloc(string->p, string->realLength + needAddLength);
		string->realLength += needAddLength; //改变字符串实际长度

		//先移动，再拷贝，这与在尾部家字符串是不同的
		int nowLength = myStrLen(string->p);//求出当前总长度
		int moveLength = myStrLen(pos);//要移动的长度，从插入位置pos一直到结尾
		int insertLength = myStrLen(str);//求出要插入的字符串的长度

		for (int i = nowLength; i >= nowLength - moveLength; i--)
		{
			string->p[i+insertLength] = string->p[i];//后移一位

		}
		//移动完成之后，插入位置腾出来了，现在插入字符
		//由于插入的是字符串所以还需要一个循环
		for (int j = 0; j < insertLength; j++)
		{
			string->p[nowLength - moveLength + j] = str[j];//插入
		}
	}
	
	else//字符串没有满，也就是存储的字符串的长度小于实际长度
	{
		//先移动，再拷贝，这与在尾部家字符串是不同的
		int nowLength = myStrLen(string->p);//求出当前总长度
		int moveLength = myStrLen(pos);//要移动的长度，从插入位置pos一直到结尾
		int insertLength = myStrLen(str);//求出要插入的字符串的长度

		for (int i = nowLength; i > nowLength - moveLength; i--)
		{
			string->p[i + insertLength] = string->p[i];//后移一位

		}
		//移动完成之后，插入位置腾出来了，现在插入字符
		//由于插入的是字符串所以还需要一个循环
		for (int j = 0; j < insertLength; j++)
		{
			string->p[nowLength - moveLength + j] = str[j];//插入
		}
	} 
}

void changeFirstChar(myString *string, const char oldChar, const newChar)
{
	char *pstr = string->p;
	while (*pstr != '\0')
	{
		if (*pstr == oldChar)
		{
			*pstr = newChar;
			return; //如果要查询所有的oldChar则不需要return。
		}
		pstr++;
	}
}
void changeFirstString(myString *string, char * const oldString, char *const newString)
{
	char *pfind = findFirstString(string, oldString); //找到要修改的字符串
	if (pfind != NULL)
	{
		deleteFirstString(string, oldString); //删除
		addString(string, newString, pfind);//插入。
	}
}

//main.c  测试文件

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include "strStr.h"

void main()
{
	myString string1;

	//字符串初始化
	initWithString(&string1, "notepad");
	
	//backAddString(&string1, "pad");
	printStr(&string1);
	
	//查找第一个匹配的字符测试
	/*char *strp = findFirstChar(&string1, 'a');
	*strp = 'A';
	printf("%c\n", *strp);*/


	//查找第一个匹配的字符串
	//char *strp = findFirstString(&string1, "ad");
	//printf("%c\n", *strp);

	//查找第一个匹配的字符串，找不到的情况返回空。
	/*char *strp = findFirstString(&string1, "addd");
	if (strp != NULL)
	{
	*strp = 'X';

	}*/
	//printStr(&string1);

	删除字符测试
	//deleteFirstChar(&string1, 'n');
	//printStr(&string1);

	删除字符串测试
	//int num = deleteFirstString(&string1, "padf");
	//printStr(&string1);
	//if (num == 0)
	//{
	//	printf("\n删除失败\n");
	//}
	//else
	//{
	//	printf("删除成功\n");
	//}


	任意位置插入字符测试
	首先找到要插入的位置
	//char *p = findFirstChar(&string1, 't');
	//if (p != NULL)
	//{
	//	addChar(&string1, 'w', p);
	//}
	//printStr(&string1);


	任意位置插入字符串测试
	//backAddString(&string1, "notepad");
	//printStr(&string1);

	//char *p = findFirstChar(&string1, 't');
	printf("%s", p);
	//if (p != NULL)
	//{
	//	//printf("test\n");
	//	addString(&string1, "12345", p);
	//	//printf("%s\n", string1);
	//}
	addString(&string1, "1345", p);
	//printStr(&string1);

	替换字符 测试
	//changeFirstChar(&string1, 'p', 'A');
	//printStr(&string1);

	//替换字符串测试
	//backAddString(&string1, "notepad");
	//changeFirstString(&string1, "pad", "I Love C++!!");
	//printStr(&string1);

	//循环改变oldString
	backAddString(&string1, "notepadnotepadnotepadnotepad");
	printStr(&string1);
	while(findFirstString(&string1, "notepad"))
	{
		changeFirstString(&string1, "notepad", "123456789");
	}
	printStr(&string1);


	//run(&string1);  //执行指令

	system("pause");
}

乱红飞
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++实现字符串mystring类的封装（难点：赋值运算符函数）
m0_37433111的博客
11-10 900
2020年11月10日 周二 天气晴 【不悲叹过去，不荒废现在，不惧怕未来】 本文目录1. 引言2. 主文件——main.cpp3. mystring.h4. mystring.cpp参考文献 1. 引言 用C++实现了简单的字符串类封装，实现了字符串赋值、相加、修改、比较等功能。完整工程放在了我的github上，有需要的也可以自取。 github地址：https://github.com/March225/High-frequency-algorithm 2. 主文件——main.cpp /** *
字符串封装
06-21
字符串封装是一种将特定功能组合在一起的方法，以提供一个简洁且易于使用的接口来操作字符串。标题"字符串封装"指的是创建自定义的函数集合，这些函数能够执行与C++标准库中的`std::string`类类似的操作，但可能具有...
【c++实战】之封装字符串类
distant_Rove666的博客
12-27 397
封装字符串类
封装 字符串
SteveRocket's-Blog
07-30 805
string.h#define _CRT_SECURE_NO_WARNINGS #include #include #include //字符串的封装 typedef struct CString { char *p;//保存字符串首地址 int realLength;//字符串实际长度 }mystring; //初始化 void init(mystring*string);
学习C++的第9天之封装简单的字符串类的分析与实现
weixin_45573229的博客
07-12 123
第八天学习的运算符重载，感觉没学明白就先不做太多笔记了，就写一点点比较重要的东西吧 运算符重载 一个空类里面编译器默认提供了四种函数： 1、构造函数 (包括有参和无参) 2、拷贝构造函数 (解决浅拷贝的问题) 3、析构函数 4、赋值运算符的重载 (解决浅拷贝的问题) 字符串类的封装 采用分文件编写的方式，在头文件中进行声明，在cpp源文件中进行实现。 类的属性设置为私有，属性包括了开辟在堆区的指针以及记录字符串长度，此处的长度不统计’\0’。 需求 私有属性： 1、开辟在堆区的字符指针 2、
C语言总结：字符串函数封装练习（十四种示例）
致力于C语言C++知识分享！
05-04 820
字符串函数重写练习：字符串比较、字符串拼接、字符串查找、字符串拷贝、内存比较、内存拷贝、内存初始化、内存比较、二维数组定义及基本使用、位运算练习–通过取模打印中文字模在控制台。 1. memcpy内存拷贝 #include <stdio.h> //标准输入输出 #include <string.h> //字符串处理头文件 int main(int argc,char **argv) { char str1[]="1234567"; char str2[100]; m
字符串封装源代码
04-27
完成了字符串的封装，基本实现了字符串库函数处理的功能。
iOS属性字符串封装库
09-09
总之，`MyAttributedString`是一个针对iOS平台的NSAttributedString封装库，它的存在极大地简化了属性字符串的处理，提高了开发效率。如果你在iOS应用开发中需要处理复杂的文本样式，那么这个库无疑是一个值得尝试的...
PHP封装的字符串加密解密函数
10-23
本文将详细介绍如何使用PHP封装的字符串加密解密函数，以及它们的工作原理。 首先，我们来看一个简单的自定义加密解密函数示例： ```php function encrypt($string, $operation, $key='') { $key = md5($key); $...
常用字符串函数的封装.c
东哥的博客
01-05 535
#includechar *p =NULL ;int my_strlen(const char*s) //求字符串长度{ int i=0; while(s[i++]) ; i-- ; return i ;}char * my_strcpy(char*dest,const char*src) //字符串复制{  if(src ==NULL||dest == NULL) return 0; if(d
封装一个,完善字符串，字符串的基本操作
05-05
定义一个串类CMyString，建立适当的构造函数 必须实现如下操作，字符串比较、求串的长度、判断串是否为空、将串置空、字符串赋值（包括两个字符串类复制，一个字符串赋值到CmyString对象）、求字符串中的一个字符或改变字符串中的一个字符（采用重载[]），完成串的赋值与合并（重载+）。
设计一个字符串类，并将字符串处理函数的内容进行封装
alsss20160603的博客
10-28 343
#include<iostream> using namespace std; class String { public: //定义类的成员变量 char s[10] = "abcd"; char *ps = s; const char t[10] = "dcba"; const char *pt = t;...
C++ 字符串各种类型转换的函数封装 【宝藏博客】
陈子青的博客
08-04 557
【函数封装】C++ 字符串各种类型转换的函数封装 【宝藏博客】
[C语言]封装字符串功能函数
不分解的单应矩阵
10-12 404
题目 函数实现 函数一 //去除字符串前后的空格 int trimSpace(char* inbuf, char* outbuf) { int ret = 0; char* tempinbuf = inbuf; //临时指针指向原字符串首地址 char* tempoutbuf = outbuf; //判断地址是否有效 if (inbuf == NULL || outbuf == NULL) { ret = -1; printf("func trimSpace()err(inb
有关于字符串操作的封装的函数---用于命令行解析
weixin_45606518的博客
08-02 140
*void str_trim_crlf(char str); //去除\r\n void str_trim_crlf(char *str) //去除每行最后的\r\n { char *p = str[strlen(str)-1]; //指向最后一个字符 while(*p=='\r'||*p=='\n'){ *p --= '\0'; } } **void str_split(const char *str , char le
#include "stdio.h";#include <stdio.h>#include <iostream>;#include <iostream.h>区别
浴血重生-学习空间
12-16 3417
#include XXXXX 表示包含C/C++文件 ，该指令不仅局限于.h 头文件，可以包含任何编译器能识别的C/C++代码文件， 包括.c,.hpp,.cpp,.hxx,.cxx等，甚至.txt,.abc等等都可以。 #include 包含系统头文件， 在标准库目录里面寻找。 #include "..." 包含用户自定义的头文件,一般先在当前工程的目录搜索，如果找到的话，就OK。如
c#-10字符串对象及封装常用方法
m0_55746013的博客
12-06 400
c#字符串对象
字典序排序输入的字符串
黄上的博客
12-22 374
#include <stdio.h> #include <stdlib.h> #include <string.h> //字典序排序字符串 #define MAX_LEN 200 #define N 200 int main() { int n; char words[N][MAX_LEN]; char str[MAX_LEN]; gets(str); n = GetWords(str,words); SortStrin
C#中String类型字符串内封装的一些方法及其使用情况
vesard的博客
07-16 934
C#中String类型字符串内封装的一些方法及其使用情况 string str = "abcdefg"; str.ToUpper();//将字符串全部转换为大写 str.ToLower();//将字符串全部转换为小写 str.Trim();//去掉字符串中的空格 str.PadLeft(10,'*');...
如何使用fastjson将解析的字符串封装到对象中
最新发布
04-15
好的，关于使用fastjson将解析的字符串封装到对象中，你可以参考下面的示例代码： ``` import com.alibaba.fastjson.JSON; public class Test { public static void main(String[] args) { // 假设以下是json...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值