C语言： 字符串 -3

自定义字符串函数实现：

头文件：

/*
	自定义字符串库头文件 MyString.h
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

/*
    字符串结构体
    参数： P: 字符串首地址         
    参数  realLenght：字符串实际长度        
*/
struct CString
{
    char *p; //保存字符串首地址
    int realLenght; //字符串实际长度
};

//结构体取一个别名
typedef struct CString mystring;

//初始化
void init(mystring *string);
//初始化,并分配指定长度存储空间，且内存清零
void initWithLenght(mystring *string,int lenght);
//初始化，并拷贝字符串
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 char newChar);

//替换字符串
void changeFirstString(mystring * string, const char* oldStr, const char* newStr);

函数实现：

#define _CRT_SECURE_NO_WARNINGS
#include"MyString.h"
#include<string.h>

//求字符串长度
//参数：*p 字符串首地址
int myStrlen(char *p)
{
    if (p == NULL)
    {
        return -1; //字符串为空
    }
    int lenght = 0;
    while (*p!='\0') //字符串终止条件
    {
        lenght++; //长度自增
        p++; //指针自增
    }
    return lenght;
}

//字符串拷贝
//参数：*dest  To String
//参数：*source  from String 加const 限定源被意外修改
char* myStrcpy(char* dest, const char* source)
{
    if (dest == NULL || source == NULL)
    {
        return NULL;
    }

    char * destBak = dest;
    while (*source!='\0')
    {
        *dest = *source;
        dest++;
        source++;
    }
    *dest = '\0'; //添加结束符
    return destBak; //返回首地址
}

//字符串连接相加
//参数：*dest  源字符串
//参数：*source  要相加的字符
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;
    }
}


char *mystrchar(const char * dest, char ch)
{
    if (dest == NULL)
    {
        return NULL;
    }

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

//查找字符串中是否包含字符串
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') //外层循环，源
    {
        char * findStrbak = findStr;
        char *nowdestbak = destbak; //备份查找地址
        int flag = 1; //假定相同
        while (*findStrbak!='\0') //内层循环，要查找的字符串
        {
            if (*nowdestbak != '\0')
            {
                if (*findStrbak != *nowdestbak)
                {
                    flag = 0;//不同赋值为0
                }
                nowdestbak++;
                findStrbak++;
            }
            else
            {
                flag = 0;
                break;
            }
            
        }
        if (flag == 1)
        {
            p = destbak;//当前位置
            return p;
        }
        destbak++;
    }
    
    return NULL;

}



//返回字符串中查找字符的第一个匹配字符
//参数：*string  结构体数据类型
//参数：ch  要找的字符
char * findFirstChar(mystring *string, char ch)
{
    char *p = mystrchar(string->p, ch);
    return p;
}


//返回字符串中查找字符串的第一个匹配字符串
char * findFirstString(mystring *string, char *str)
{
    char *value = myStrstr(string->p, str);
    return value;
}

//初始化，原始值
//参数：*string  结构体数据类型
void init(mystring *string)
{
    string->p = NULL;
    string->realLenght = 0;
}

//初始化,并分配指定长度存储空间，且内存清零
//参数：*string  结构体数据类型
//参数：lenght  数据长度
void initWithLenght(mystring *string, int lenght)
{
    //string->p = (char *)malloc(sizeof(char)*lenght); //malloc分配内存时，内存空间不为0，有脏数据
    string->p = (char *)calloc(lenght, sizeof(char)); //分配内存，并清零。
    string->realLenght = lenght;
}


//初始化，并拷贝字符串
//参数：*string  结构体数据类型
//参数：*copystring  要复制的字符串
void initWithString(mystring *string, char *copystring)
{
    int lenght = myStrlen(copystring); //获取字符串长度，但不包括字符串结束符'\0'
    string->p =(char *) calloc(lenght + 1, sizeof(char)); //分配内存空间
    myStrcpy(string->p, copystring); //拷贝字符串
    string->realLenght = lenght + 1; //长度加1，切记
}


//打印字符串
//参数：*string  结构体数据类型
void printfString(mystring *string)
{
    printf("\nString : %s", string->p);
}

//尾部增加字符
//参数：*string  结构体数据类型
//参数：ch  要增加的字符
void backAddChar(mystring * string,char ch)
{
    if (myStrlen(string->p) + 1 == string->realLenght) //字符串长度已满
    {
        string->p = realloc(string->p, string->realLenght + 1); //增加内存存储空间
        string->realLenght += 1; //长度加1
        string->p[string->realLenght - 2] = ch;
        string->p[string->realLenght - 1] = '\0';
    }
    else
    {
        int nowLenght = myStrlen(string->p);
        string->p[nowLenght] = ch;
        string->p[nowLenght + 1] = '\0';
    }
}

//尾部增加字符串
//参数：*string  结构体数据类型
//参数：*str  要增加的字符串
void backAddString(mystring * string, char * str)
{
    int nowMyStrlen = myStrlen(string->p); //获取当前字符串长度
    int addStrlen = myStrlen(str); //获取要增加的字符串长度

    if (nowMyStrlen + addStrlen + 1 > string->realLenght) //判定长度是否越界
    {
        int needAddlen = nowMyStrlen + addStrlen + 1 - (string->realLenght); //获取需要添加的内存长度
        string->p = (char *)realloc(string->p, needAddlen+(string->realLenght));
        myStrCat(string->p, str); //拷贝字符串
        string->realLenght += needAddlen; //增加长度
    }
    else
    {
        myStrCat(string->p, str); //拷贝字符串
    }
}

//执行字符串指令
//参数：*string  指令字符串
void run(mystring *string)
{
    system(string->p);
}

//删除字符中字符
//参数：*string  结构体数据类型
//参数：ch  要删除的字符
//return  ： 1 成功 0 失败
int deletefirstChar(mystring *string, const char ch)
{
    
    char *p = mystrchar(string->p, ch);
    if (p == NULL)
    {
        return 0;
    }
    else
    {
        char *pNext = p + 1;
        while (*pNext != '\0')
        {
            *p = *pNext;
            p++;
            pNext++;
        }
        *p = '\0';
        return 1;
    }
   
}


//删除字符串中字符串
//参数：*string  结构体数据类型
//参数：str  要删除的字符串
//return  ： 1 成功 0 失败
int deletefirstString(mystring *string, char * const str)
{
    char *p = myStrstr(string->p, str);
    if (p == NULL)
    {
        return 0;
    }
    else
    {
        int lenght = myStrlen(str);//求字符串长度
        char* pNext = p + lenght;
        while (*pNext!='\0')
        {

            *p = *pNext;
            p++;
            pNext++;
        }
        *p = '\0';
        return 1;
    }

}

//任意位置增加字符
void AddChar(mystring * string, char ch, char * pos)
{
    if (string == NULL || pos == NULL)
    {
        return;
    }
    if (myStrlen(string->p) + 1 == string->realLenght) //内层满了
    {
        string->p = realloc(string->p, string->realLenght + 1);
        string->realLenght += 1;
        int nowLen = myStrlen(string->p);//求出当前长度
        int moveLen = myStrlen(pos); //求出要移动的长度
        for (int i = nowLen; i > nowLen - moveLen; i--)
        {
            string->p[i] = string->p[i - 1]; //轮询 向后移动
        }
        string->p[nowLen - moveLen] = ch;
        string->p[nowLen + 1] = '\0';

    }
    else
    {
        int nowLen = myStrlen(string->p);//求出当前长度
        int moveLen = myStrlen(pos); //求出要移动的长度
        for (int  i = nowLen; i > nowLen-moveLen; i--)
        {
            string->p[i] = string->p[i - 1]; //轮询 向后移动
        }
        string->p[nowLen - moveLen] = ch;
        string->p[nowLen + 1] = '\0';
    }


}

//任意位置增加字符串
void AddString(mystring * string, char * str, char * pos)
{
    if (string == NULL || pos == NULL)
    {
        return;
    }
    int nowMyStrlen = myStrlen(string->p); //获取当前字符串长度
    int addStrlen = myStrlen(str); //获取要增加的字符串长度

    if (nowMyStrlen + addStrlen + 1 > string->realLenght) //判定长度是否越界
    {
        int needAddlen = nowMyStrlen + addStrlen + 1 - (string->realLenght); //获取需要添加的内存长度
        string->p = (char *)realloc(string->p, needAddlen + (string->realLenght));
        string->realLenght += needAddlen;//增加长度
        int nowLen = myStrlen(string->p); //当前长度
        int moveLen = myStrlen(pos); //求出要移动的长度
        int insertLen = myStrlen(str);//插入字符串长度
        for (int i = nowLen; i > nowLen - moveLen; i--)
        {
           string->p[i + insertLen]= string->p[i]; //向后移动
        }
        for (int j = 0; j < insertLen; j++)
        {
            string->p[nowLen - moveLen + j] = str[j];
        }

    }
    else
    {
        int nowLen = myStrlen(string->p); //当前长度
        int moveLen = myStrlen(pos); //求出要移动的长度
        int insertLen = myStrlen(str);//插入字符串长度
        for (int i = nowLen; i > nowLen - moveLen; i--)
        {
            string->p[i + insertLen] = string->p[i]; //向后移动
        }
        for (int j = 0; j < insertLen; j++)
        {
            string->p[nowLen - moveLen + j] = str[j];
        }

    }

}

//替换
void changeFirstChar(mystring * string, const char oldChar, const char newChar)
{
    char *pstr = string->p;
    while (*pstr!='\0')
    {
        if (*pstr == oldChar) //查找
        {
            *pstr = newChar; //赋值
            return;
        }
        pstr++;
    }
}

//替换字符串
void changeFirstString(mystring * string, const char* oldStr, const char* newStr)
{
    char * find = findFirstString(string, oldStr); //找到位置
    if (find != NULL)
    {
        deletefirstString(string, oldStr); //删除原来的
        AddString(string, newStr, find); //插入新的
    }
}