字符串封装

/************************************************
*文件名：string.h
*创建者：ycj
*创建时间：2015-3-16
*文件说明：字符串查找,尾部增加,删除,任意位置增加,修改字符串（字符，字符串）

*************************************************/

//字符串，初始化，打印，
//查找，查找字符，查找字符串
//尾部增加，（字符，字符串）
//删除（字符，字符串），
//任意位置增加（字符，字符串）
//修改字符串，（字符，字符串替换）


#ifndef STRING_H
#define STRING_H

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

struct CString
{
char *p;//保存字符串首地址
int reallength;//实际长度
};
typedef struct CString mystring;//缩写


void init(mystring *string);//初始化
void initwithlength(mystring *string, int length);//开辟长度，内存清零
void initwithstring(mystring *string, char *copystring);//初始化并拷贝字符串
void printfstring(mystring *string);//打印
void backaddchar(mystring *string, char ch);//尾部增加一个字符
void backaddstring(mystring *string, char *str);//尾部增加一个字符串
void run(mystring *string);//执行指令
char *findfirstchar(mystring *string, char ch);//返回第一个找到的字符的地址
char *findfirststring(mystring *string, char *str);//返回第一个找到的字符串的地址
int deletefirstchar(mystring *string, const char ch);//删除首次找到的字符
int deletefirststring(mystring *string, char * const str);//删除首次找到的字符串
void addchar(mystring *string, char ch, char *pos);//任意位置增加一个字符
void addstring(mystring *string, char *str, char *pos);//任意位置增加一个字符串
void changefirstchar(mystring *string, const char oldchar, const newchar);//改变字符
void changefirststring(mystring *string, char * const oldstring, char * const newstring);//改变字符串

#endif

/************************************************
*文件名：string.c
*创建者：ycj
*创建时间：2015-3-16
*文件说明：字符串查找,尾部增加,删除,任意位置增加,修改字符串（字符，字符串）

*************************************************/

#include "string.h"


//自定义的求字符串长度的strlen函数
int mystrlen(char *p)
{
if (p == NULL)
{
return -1;//失败
}


int length = 0;
while (*p != '\0')//字符串的终止条件
{
length++;//长度自增
p++;//指针前移
}


return length;
}


//自定义的拷贝字符串的strcpy函数
char *mystrcpy(char *dest, const char *source)//const限定拷贝内容不被修改
{
if (dest == NULL || source == NULL)
{
return NULL;//为空没有必要干活了
}


char *destbak = dest;//保留地址
while (*source != '\0')
{
*dest = *source;//赋值字符
source++;
dest++;//指针不断向前，字符挨个赋值
}
*dest = '\0';//结尾

return destbak;//返回地址
}


//自定义的连接字符串strcat函数
char *mystrcat(char *dest, const char *source)
{
if (dest == NULL || source == NULL)
{
return NULL;//失败
}
else
{
char *destbak = dest;//保留地址
while (*dest != '\0')
{
dest++;//指针向前移动
}
//从尾部开始拷贝
while (*source != '\0')
{
*dest = *source;//字符串赋值
dest++;
source++;
}
*dest = '\0';//收尾
return destbak;
}
}


//自定义在一个串中查找给定字符的第一个匹配之处的strchr函数
char *mystrchr(const char *dest, char ch)
{
if (dest == NULL)
{
return NULL;
}


while (*dest != '\0')
{
if (*dest == ch)
{
return dest;
}
dest++;
}


return NULL;
}


//自定义在字符串中查找指定字符串的第一次出现的strstr函数
char *mystrstr(const char * const dest, const char * const findstr)
{
if (dest == NULL || findstr == NULL)
{
return NULL;
}


char *destbak = dest;
char *p = NULL;//保存找到的地址
while (*destbak != '\0')
{
int flag = 1;//假定是相等
char *findstrbak = findstr;
char *nowdestbak = destbak;
while (*findstrbak != '\0')
{
if (*nowdestbak != '\0')//出现findstr多余dest的情况
{
if (*findstrbak != *nowdestbak)
{
flag = 0;//赋值为0代表不等
break;
}
findstrbak++;
nowdestbak++;
}
else
{
flag = 0;//设置标志
break;
}
}


if (flag == 1)
{
p = destbak;//当前位置
return p;
}


destbak++;
}


return NULL;
}


//原封不动初始化
void init(mystring *string)
{
string->p = NULL;
string->reallength = 0;
}


//开辟长度，内存清零
void initwithlength(mystring *string, int 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));//分配内存
//strcpy(string->p, copystring);//拷贝字符串
mystrcpy(string->p, copystring); //拷贝字符串
string->reallength = length + 1;
}


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


//尾部添加一个字符的实现函数
void backaddone(char *p, char ch)
{
while (*p != '\0')
{
p++;
}
*p = ch;
p++;
*p = '\0';
}
//尾部增加一个字符
void backaddchar(mystring *string, char ch)
{
//sprintf(string->p, "%s%c\0", string->p, ch);//error,未分配空间


法一
//if (mystrlen(string->p) + 1 == string->reallength)//意味数据占满
//{
// //重新分配内存
// string->p = (char *)realloc(string->p, string->reallength + 1);
// string->reallength += 1;
// string->p[string->reallength - 2] = ch;
// string->p[string->reallength - 1] = '\0';
//}
//else
//{
// int nowlength = mystrlen(string->p);
// string->p[nowlength] = ch;
// string->p[nowlength + 1] = '\0';
//}


//法二
if (mystrlen(string->p) + 1 == string->reallength)
{
//重新分配内存
string->p = (char *)realloc(string->p, string->reallength + 1);
string->reallength += 1;
backaddone(string->p, ch);
}
else
{
backaddone(string->p, ch);
}
}


//尾部增加一个字符串
void backaddstring(mystring *string, char *str)
{
//sprintf(string->p, "%s%s", string->p, str);//error,未分配空间


int nowmystringlength = mystrlen(string->p);//获取当前长度
int addstringlength = mystrlen(str);//要增加的长度
if (mystrlen(string->p) + mystrlen(str) + 1 > string->reallength)//判断是否越界
{
int needaddlength = nowmystringlength + addstringlength + 1 - string->reallength;
 //printf("%d\n", needaddlength);
string->p = (char *)realloc(string->p, string->reallength + needaddlength);
//strcat(string->p, str);//拷贝字符串
mystrcat(string->p, str);//拷贝字符串
string->reallength += needaddlength;//增加长度
}
else
{
//strcat(string->p, str);//拷贝字符串
mystrcat(string->p, str);//拷贝字符串
}
}




//执行指令
void run(mystring *string)
{
system(string->p);
}


//返回第一个找到的字符的地址
char *findfirstchar(mystring *string, char ch)
{
//char *p = strchr(string->p, ch);
char *p = mystrchr(string->p, ch);


return p;
}


//返回第一个找到的字符串的地址
char *findfirststring(mystring *string, char *str)
{
//char *pres = strstr(string->p, str);
char *pres = mystrstr(string->p, str);


return pres;
}


//删除首次找到的字符
int deletefirstchar(mystring *string, char ch)
{
char *p = mystrchr(string->p, ch);
if (p == NULL)
{
return -1;//失败-1，未找到删除的字符
}
else
{
char *pnext = p + 1;
while (*pnext != '\0')
{
*p = *pnext;
p++;
pnext++;
}
*p = '\0';


return 0;//成功删除，返回值0
}


}


//删除首次找到的字符串
int deletefirststring(mystring *string, char *str)
{
char *p = mystrstr(string->p, str);
if (p == NULL)
{
return -1;//失败-1，未找到删除的字符串
}
else
{
int length = mystrlen(str);//求字符串长度
char *pnext = p + length;

while (*pnext != '\0')
{
*p = *pnext;
p++;
pnext++;
}
*p = '\0';


return 0;//成功删除，返回值0
}
}

//任意位置增加一个字符
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);
string->reallength += 1;


int nowlength = mystrlen(string->p);//求出当前长度
int movelength = mystrlen(pos);//求出现在要移动的长度


for (int i = nowlength; i > nowlength - movelength; i--)
{
string->p[i] = string->p[i - 1];//循环赋值
}


string->p[nowlength - movelength] = ch;//插入
string->p[nowlength + 1] = '\0';
}
else
{
int nowlength = mystrlen(string->p);//求出当前长度
int movelength = mystrlen(pos);//求出现在要移动的长度

for (int i = nowlength; i > nowlength - movelength; i--)
{
string->p[i] = string->p[i - 1];//循环赋值
}


string->p[nowlength - movelength] = ch;//插入
string->p[nowlength + 1] = '\0';
}
}


//任意位置增加一个字符串
void addstring(mystring *string, char *str, char *pos)
{
if (pos == NULL || string == NULL)
{
return;//失败
}


if (mystrlen(string->p) + mystrlen(str) + 1 > string->reallength)//判断是否越界
{
//先移动，在拷贝
int nowlength = mystrlen(string->p);//求出当前长度
int movelength = mystrlen(pos);//求出现在要移动的长度
int insertlength = strlen(str);//要求出插入的长度


int needaddlength = nowlength + insertlength + 1 - string->reallength;
string->p = (char *)realloc(string->p, string->reallength + needaddlength);

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];
}


string->p[nowlength + insertlength] = '\0';
}
else
{
//先移动，在拷贝
int nowlength = mystrlen(string->p);//求出当前长度
int movelength = mystrlen(pos);//求出现在要移动的长度
int insertlength = strlen(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];
}


string->p[nowlength + insertlength] = '\0';
}
}


//改变字符
void changefirstchar(mystring *string, const char oldchar, const char newchar)
{
char *p = string->p;
while (*p != '\0')
{
if (*p == oldchar)
{
*p = newchar;
return;
}
p++;
}
}


//改变字符串
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);
}
}

/************************************************
*文件名：test.c
*创建者：ycj
*创建时间：2015-3-16
*文件说明：测试库功能

*************************************************/

#include "string.h"
#pragma comment(lib, "字符串库.lib")


void main()
{
mystring string1;
init(&string1);
initwithstring(&string1, "dd");
//printfstring(&string1);
backaddchar(&string1, ',');
//printfstring(&string1);
backaddstring(&string1, "i love you");
printfstring(&string1);


char *pstr1 = findfirstchar(&string1, 'y');
*pstr1 = 'Y';
printfstring(&string1);


char *pstr2 = findfirststring(&string1, "love You");
if (pstr2 != NULL)
{
*pstr2 = 'L';
}
else
{
printf("没有找到\n");
}
printfstring(&string1);


deletefirstchar(&string1, 'u');
printfstring(&string1);


deletefirststring(&string1, "Love");
printfstring(&string1);


char *p = findfirstchar(&string1, 'd');
addchar(&string1, 'q', p);
printfstring(&string1);


addstring(&string1, "love", " Yo");
printfstring(&string1);


changefirststring(&string1, "Yo", "you");
printfstring(&string1);
system("pause");
}