C字符串总结+字符串库实现（增，改，删，查）：

《一》，字符指针&字符数组

     两者形式：

          字符指针：char *p;

          字符数组：char str[100];

     两者区别：

          字符指针p是变量；

          字符数组str是常量；

     访问元素方式：

           字符指针：*(p+i) || p[i]，    访问第i个元素；

           字符数组：*(str+i) || str[i]   访问第i个元素；

      利用 sizeof() 求大小：

           字符指针： sizeof(p) = 4,       sizeof(p)求的是指针p所占的空间，恒为4字节；

           字符数组： sizeof(str) = 100, sizeof(str)求的是数组str的真实空间，100；

       字符串函数strlen()说明：

           strlen()仅仅求出字符串中第一个''之前的字符个数，

           printf("%s",str)只输出第一个''之前的字符个数；

           函数原型：

           int strlen(char *p)

           {

                   int count=0;

                   if(p==NULL)

                       return count；

                   while(*p++ != '')

                       count++;

                   return count;

           }

      简单实例：

          

#define  _CRT_SECURE_NO_WARNINGS //关闭安全检查
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//for语句
int mystrlen(char* str)
{
    int i = 0;
    for (char*p = str; *p != ''; p++)
    {
        i++;
    }
    return i;//实现字符串统计
}

//go语句
int mystrlenA(char* str)
{
    char *p = str;
    int i = 0;
AAA: if (*p!='')
{
         i++;
         p++;
         goto AAA;
}
     return i;
}


//递归实现
int mystrlenB(char *str)
{
    if (*str=='')
    {
        return 0;
    }
    else
    {
        return 1 + mystrlenB(++str);
    }


}



void  main()
{
    char str[100] = "china is good";
    char *p = str;
    char *q = malloc(sizeof(char)*50);
    q = "hello,i am q";
    printf("str:%s",str);
    printf("
sizeof(str):%d", sizeof(str));
    printf("
strlen(str):%d", strlen(str));
    printf("

p:%s", p);
    printf("
sizeof(p):%d", sizeof(p));
    printf("
strlen(p):%d", strlen(p));
    printf("

q:%s", q);
    printf("
sizeof(q):%d", sizeof(q));
    printf("
strlen(q):%d", strlen(q));

    printf("
%d", mystrlen(str));//从开头第一个字符到字符
    printf("
%d", mystrlenA(str));
    printf("
%d", mystrlenB(str));

    getchar();
}

      运行结果：

      

《二》

       字符串库实现：

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

     

       String.c

#include"字符串.h"

int mystrlen(char *p)
{
    if (p == NULL)
    {
        return -1;//失败，
    }
    int length = 0;
    while (*p != '')//字符串终止条件
    {
        length++;//长度自增
        p++;//指针不断向前
    }
    return length;

}
char *mystrcpy(char *dest, const char *source)//const限定不被意外修改
{
    if (dest == NULL || source == NULL)
    {
        return  NULL;//为空没有必要干活了
    }
    char * destbak = dest;
    while (*source != '')//一直拷贝
    {
        *dest = *source;//赋值字符
        source++;
        dest++;//指针不断向前，字符挨个赋值
    }
    *dest = '';//结尾
    return destbak;//返回地址

}

char *mystrcat(char *dest, const char *source)
{
    if (dest == NULL || source == NULL)
    {
        return NULL;//失败
    }
    else
    {
        char *destbak = dest;//保留地址
        while (*dest != '')
        {
            dest++;//指针向前移动
        }
        //从尾部开始拷贝
        while (*source != '') //循环被被拷贝的字符串
        {
            *dest = *source;//字符串赋值
            dest++;
            source++;

        }
        *dest = '';//结尾
        return destbak;

    }



}

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

    while (*dest!='')
    {
        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 != '')
    {
        int flag = 1;//假定是相等
        char *findstrbak = findstr;
        char *nowdestbak = destbak;
        while (*findstrbak != '')
        {
            if (*nowdestbak != '')
            {

                if (*findstrbak != *nowdestbak)//有一个不等
                {
                    flag = 0;//赋值为0代表不等
                }
                nowdestbak++;
                findstrbak++;
            }
            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 *) 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);//拷贝字符串
    string->reallength = length + 1;//设置长度

}
void backaddchar(mystring *string,char ch)
{
    
    if (mystrlen(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] = '';

    }
    else
    {
        int nowlength = mystrlen(string->p);//求出当前长度
        string->p[nowlength] = ch;
        string->p[nowlength + 1] = '';//字符的增加

    }

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

    }
    else
    {
        mystrcat(string->p, str);//拷贝字符串



    }



}
void printfstring(mystring *string)
{

    printf("
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 != '')
       {
           *p = *pnext; //删除一个字符整体向前移动
           p++;
           pnext++;
       }
       *p = '';//字符串要有结尾
       return 1;
    }
    



}
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 != '')
        {
            *pres = *pnext; //删除一个字符整体向前移动
            pres++;
            pnext++;

        }
        *pres = '';//字符串要有结尾
        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 = 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] = '';//结尾

    }
    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] = '';//结尾



        

    }



}
void addstring(mystring *string, char*str, char *pos)//任意增加字符串
{
    if (pos == NULL || string == NULL)
    {
        return;
    }
    int nowmystringlength = mystrlen(string->p);//获取当前长度
    int addstringlength = mystrlen(str);//要增加的长度
    if (nowmystringlength + addstringlength + 1 >string->reallength)//判定是否越界
    {
        int needaddlength = nowmystringlength + addstringlength + 1 - (string->reallength);
        //printf("%d", needaddlength);
        string->p = (char *)realloc(string->p, string->reallength + needaddlength);//增加字符串长度
        string->reallength += needaddlength;//增加长度

        //先移动，再拷贝
        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];//赋值拷贝
        }

    }
    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];//赋值拷贝
        }

        //



    }


}
void  changefirstchar(mystring *string, const char oldchar, const newchar)//改变字符
{
    char *pstr = string->p;
    while (*pstr != '')
    {
        if (*pstr == oldchar)//查找
        {
            *pstr = newchar;//赋值
            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);//插入
    }


}

     

特别说明：《C Primer Plus》第五版 第10章有数组，指针，函数的详细讨论，11章详细介绍字符串·相关操作；