使用C语言对字符串操作的分装

使用C语言对字符串操作的分装

封装字符串函数

#include"字符串.h"
//拷贝字符串   追加到一个字符串中
char *mystrcat(char *dest,const char *copystring)
{
    if(dest==NULL || copystring==NULL)
    {
        return NULL;
    }else
    {
        //保存首地址
        char *first_addr=dest;
        //循环到dest ==\0
        while(*dest!='\0')
        {
            dest++;
        }
         while(*copystring!='\0')
        {
            //拷贝字符串
            *dest=*copystring;
            //指针向前移动
            copystring++;
            dest++;
        }
        *dest='\0';
        return first_addr;
    }
}

//在尾部增加字符
void endaddchar(mystring *string,char ch){
    //判断原来的长度是否够用
    if(strlen(string->p)+1 == string->real_length){
        //重新分配内存
        string->p =realloc(string->p,string->real_length+sizeof(char));
        string->p[string->real_length-2]=ch;
        string->p[string->real_length-1]='\0';
    }else{
        //求当前字符串长度
        int nowlength=mystrlen(string->p);
        string->p[nowlength]=ch;
        string->p[nowlength+1]='\0';
    }
}
//增加字符串
void endaddstring(mystring *string,char*str)
{

    int now_mystring_length = mystrlen(string->p);
    int add_string_len=mystrlen(str);
    if(now_mystring_length+add_string_len+1 > string->real_length)
    {
         //空间不够 需要重新分配一块内存

         //需要增加的长度
        int needaddlen=now_mystring_length+add_string_len+1-string->real_length;
        string->p=(char *)realloc(string->p,string->real_length+needaddlen);
        mystrcat(string->p,str);//拷贝字符串
        //新一个字符串的长度
        string->real_length+=needaddlen;
    }else
    {
        mystrcat(string->p,str);//拷贝字符串
    }
}

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

//实现strcpy 功能，
//直接拷贝， 将一个字符串完整的拷贝到 一个指针里
//const 防止意外被修改
char *mystrcpy(char *dest,const char *source)
{
    if(dest==NULL || source==NULL){
        return NULL;
    }
    //保存首地址
   char *first_add= dest;
    while(*source != '\0'){
        *dest=*source;
        //移动指针
        source++;
        dest++;
    }
    //字符串结尾
    *dest='\0';
    return first_add;
}


//求字符串长度
int mystrlen(char *p)
{
    if(p == NULL){
        return -1;
    }
    int length=0;
    while(*p != '\0'){
        length++;
        p++;//指针向前移动一个字符
    }
    return length;
}

void init(mystring *string){
    string->p=NULL;
    string->real_length=0;//初始化结构体字符串

}
//开辟长度，内清零
void init_with_length(mystring *string,int length){
    //分配内存并清零
    string->p=(char *)calloc(length,sizeof(char));
    string->real_length = length;
}
//初始化并拷贝
void init_with_strting(mystring *string, char *copystring){
    int length =mystrlen(copystring);
    //分配内存
    string->p=(char *)calloc(length+1,sizeof(char));
    //拷贝字符串
    mystrcpy(string->p,copystring);
    string->real_length = length+1;//注意 +1 存 \0
}
//打印字符串
void printfstring(mystring *string){
    printf("\nstring= %s ",string->p);
}

char *mystrchr(const char *dest,char ch)
{
    if(dest==NULL)
    {
        return NULL;
    }else
    {
        while(*dest!='\0')
        {
            if(*dest != ch)
            {
                dest++;
            }else
            {
                break;
            }
        }
        return dest;
    }
}

//查找第一字符   有bug
char *findfirstchar(mystring *string,const char ch)
{
    char *p=mystrchr(string->p,ch);
    return p;
}
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'){
                 if(*findstrbak != *nowdestbak){
                    flag=0;
                    break;
                 }
                findstrbak++;
                nowdestbak++;
             }else{
                flag=0;
                break;
             }
         }
         if(flag==1){
            p=destbak;
           return p;
         }
         destbak++;
    }
    return NULL;
}
char *findfirststring(mystring *string,char *str)
{
    char *pres=mystrstr(string->p,str);
    return pres;
}

int deletefirstchr(mystring *string,char ch)
{

    if(string->p == NULL)
    {
        return 0;
    }
    char *p=mystrchr(string->p,ch);
    if(p==NULL)
    {
        return 0;
    }
    char *pnext=p+1;
    while(*pnext != '\0')
    {
       *p=*pnext;
       p++;
       pnext++;
    }
    *p='\0';//字符串必须要有 \0 结尾
    return 1;
}

int deletefirststring(mystring *string,char *str)
{
     if(string->p == NULL)
    {
        return 0;
    }
    char *prestr=mystrstr(string->p,str);
    if(prestr==NULL)
    {
        return 0;
    }
    int length=mystrlen(str);
    char *pnext=prestr+length;//
    while(*pnext != '\0')
    {
       *prestr=*pnext;
       prestr++;
       pnext++;
    }
    *prestr='\0';//字符串必须要有 \0 结尾
    return 1;
}

头文件（字符串.h）

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

struct CString{
    char *p;//保存字符串首地址
    int real_length;//实际长度
};

typedef struct CString mystring;//简写
void init(mystring *string);//原封不动初始化
//开辟长度，内清零
void init_with_length(mystring *string,int length);
//初始化并拷贝
void init_with_strtinfg(mystring *string, char *copystring);
//打印字符串
void printfstring(mystring *string);
//增加字符串 尾部 任意位置
//尾部增加
void endaddchar(mystring *string,char ch);
void endaddstring(mystring *string,char *str);
void run(mystring *string);
//拷贝字符串
//void mystrcat(char *dest,char *copystring);
//查找一字符 第一次出现位置
char *findfirstchar(mystring *string,char ch);
char *findfirststring(mystring *string,char *str);

//删除字符
int deletefirstchr(mystring *string,char ch);
int deletefirststring(mystring *string,char *str);