字符串函数与指针的结合使用doc.docx

字符串函数与指针的结合使用doc.docx

《字符串函数与指针的结合使用doc.docx》由会员分享，可在线阅读，更多相关《字符串函数与指针的结合使用doc.docx（19页珍藏版）》请在冰豆网上搜索。

字符串函数与指针的结合使用doc

what'sinstring？

c语言string类函数实现汇总觉得都是学习使用指针的好例子（算是读书摘抄和笔记吧）

看到很多地方都面试或者考试都要涉及字符串的很多知识有的需要自己写字符串最近看书的收集了一些算是摘抄然后在其中加了点我自己的感受嘿嘿

strcpy函数，作用是将一个字符串的字符复制到另一个字符串中

char*strcpy（char*destination,constchar*source）

{

  while（*destination++=*source++）;//看这一句话写的，精炼间断而又让人一目了然

  //我用while写肯定是要三条语句，循环变量，赋值，递增，唉。

。

。

这就是菜鸟啊

  return（destination-1）;

}

strcat函数，作用是将一个串的内容追加到另一个串上

char*strcat（char*target,constchar*source）

{

  char*original=target;

  while（*target）//这里可以看出指针和数组下标的不同，一直都觉得指针式很有优势的

  target++;

  while（*target++=*source++）;

  return（original）;//注意到与上面一个函数返回的不同

}

strncat函数，这个不常用，作用是给字符串追加了N个字符

char*strcat（char*destination,constchar*source，intn）

{

  char*original=destination;

  inti=0;

  while（*destination）

  destination++;

  while（（i++

  //这个容错性的想到也很牛，只要n为负数，就将目标字符串改为空

  if（i>n）

    *destination=NULL;

  return（original）;

}

strlwr和strupr函数这两个函数实现起来比较简单，就不列了：

）

str_index函数作用是返回索引到串的首次出现

intstr_index（constchar*string,charletter）

{

  char*original=string;

  while（（*string!

=letter）&&（*string））

        string++;

  return（string-original）;//这个返回方法，没有一定功力估计很难想出来，至少脑子里不会首先会想到这样写

}

strrchr函数也是不常用的函数作用是搜索字符在字符串中的末次出现

char*strrchr（constchar*string,charletter）

{

     char*ptr=NULL;

     while（*string）//这个逻辑在很多地方都有用

    {

         if（*string==letter）

                ptr=string;

                string++;

    }

    return（ptr）;

}

strchr函数作用是获取字符串中第一次出现某个字符

char*strchr（constchar*string,charletter）

{

     while（（*string!

=letter）&&（*string））

                string++;

    return（string）;

}

strr_index函数作用是返回指向字符串末次出现的索引

intstrr_index（constchar*string,charletter）

{

    char*original=string;

    char*ptr=NULL;

    while（*string）

   {

       if（*string==letter）

            ptr=string;

            string++

   }

   return（（*ptr）?

ptr-original:

string-original）;//要么返回末次出现的索引，要么返回字符串的长度

}

charcnt函数作用是计算字符串中字符出现的次数

intcharcnt（constchar*string,charletter）

{

   intcount=0;

   while（*string）

       if（*string==letter）

           count++;

       return（count）;

}

strrev函数作用是将字符串内容反转

char*strrev（char*string）

{

    char*original=string;

    char*forward=string;

    chartmp;

    while（*string）

        string++;

    while（forward

    {

          temp=*（--string）;

          *string=*forward;

          *forward++=tmp;

    }

    return（original）;

}

strset函数作用是将某特定字符赋给字符串相当于用某一个字符重置字符串不是很难的函数：

）

strcmp函数作用是比较两个字符串相同返回0，第一个大返回-1，第二个大返回1

intstrcmp（constchar*s1,constchar*s2）

{

   while（（*s1==*s2）&&（*s1））//这个比较的方式很简练吧，也很有逻辑

   {

         s1++;

         s2++;

   }

   if（（*s1==*s2）&&（!

*s1））

        return（0）;

   elseif（（*s1）&&（!

*s2））

        return（-1）;

   elseif（（!

*s1）&&（*s2））

        return

（1）;

   else

       return（（*s1>*s2）?

-1:

1）;

}

strncmp函数作用是比较两个字符串的前N个字符实现和上面的函数很类似只是要添加一个控制变量控制下长度:

）

strdup函数 作用是复制字符串的内容

strdup（constchar*s1）

{

   char*ptr;

   if（（ptr=malloc（strlen（s1）+1）））

         strcpy（ptr,s1）;

   return（ptr）;

}

strspn函数作用是从给定字符序列中查找字符的首次出现

size_tstrspn（constchar*s1,constchar*s2）//这个函数我看了很久才明白是什么意思，比如第一个参数传abcDef,第二个传cbA,                                                             //按照顺序查找第一个字符串，可以找到第一个没有在第二个字符串中出现的字符是'D'

                                                               //返回这个字符在第一个字符串中的索引，也就是3,另外，为什么不用int而用size_t做

                                                               //返回值，是因为site_t是unsignedint，也就是正数

{

    inti,j;

    for（i=0;*s1;i++,s1++）

    {

         for（j=0;s2[j];j++）

              if（*s1==s2[j]）

                    break;

         if（s2[j]==NULL）

              break;

    }

    return（i）;

}

strstr函数作用是在字符串中查找子字符串虽然返回值是char*但是这个函数应该在判断有没有找到子字符串情况下用的多些

char*strstr（constchar*s1,constchar*s2）

{

        int i,j,k;

        for（i=0;s1[i];i++）

            for（j=i,k=0;s1[j]==s2[k];j++,k++）

                  if（!

s2[k+1]）

                      return（s1+i）

        return（NULL）;

}

strstr_cnt函数作用是计算字符串出现的次数实现差不多是strstr和cnt的组合:

）

substring_index函数作用是给子字符串获取索引只要将strstr的返回值改成i就可以了:

）

r_strstr函数作用是获取子字符串最右端出现和strstr差不多然后参照一般的查找最右端的函数:

）

strstr_rem函数作用是从字符串中删除子字符串

char*strstr_rem（char*string,char*substring）//我没有仔细看这个函数，我有点懒，嘿嘿，但是按照上面的strstr在找到字符串后进行

                                                                  //进行替换，具体过程没看列出来可以学习

{

     int i,j,k,loc=-1;

        for（i=0;string[i]&&（loc==-1）;i++）

            for（j=i,k=0;string[j]==substring[k];j++,k++）

                  if（!

substring[k+1]）

                      loc=i;

       if（loc!

=-1）

        {

                for（k=0;substr[k];k++）;

                for（j=loc;i=loc+k,string[i];j++,i++）

                        string[j]=string[i];

                 string[i]=NULL;

        }

       return（string）

}

strstr_rep函数作用是用另一个字符串代替子字符串

char*strstr_rep（char*source,char*old,char*new）

{

    char*original=source;

    chartemp[256];

    intold_length=strlen（old）;

    int i,j,k,location=-1;

        for（i=0;source[i]&&（location==-1）;i++）

            for（j=i,k=0;source[j]==old[k];j++,k++）

                  if（!

old[k+1]）

                      location=i;

     if（location!

=-1）

     {

          for（j=0;j

                 temp[j]=source[j];

          for（i=0;new[i];i++,j++）

                 temp[j]=new[i];

          for（k=location+old_length;source[k];k++,j++）

                  temp[j]=source[k];

          temp[j]=NULL;

         for（i=0;source[i]=temp[i];i++）;

     }

     return（original）;

}

C语言指向字符串的指针  

2011-01-1922:

39:

42|  分类：

数据结构|  标签：

|字号大中小 订阅

定义字符串　＆＆　字符串数组

   chararr[]={"123"};//或者是{'1','2','3' };

   charstr[][6]={"i'm","28","year","old","my","dear","u"};

//注意要指定高维数组的大小 其长度为该数组最长元素的字符个数+1

用指针对二维数组的取值（要写到二维数组区域中）

假设一个一维数组a[]

很显然一维数组取值是*（a+i） i代表指针的偏移量a表示的是该数组的首地址

二维数组其实也就如同一维数组只不过这个一维数组的元素是一个一维数组

所以对于二维数组arr[][]*（*（arr+i）+j） arr+i是指向到arr中第i个元素

*（arr+i）就是指向到2维数组中某一个元素该元素本身又是一个数组

因此综合起来就是*（*（arr+i）+j）

虽然二维数组可以理解为一维数组但是不能通过*p=arr这样的方式去指向

voidtestArr（）{

   intarr1[]={1,2,3};

   int*p=arr1;//这句话拆开应该是int*p;p=arr1 最终p才是指针变量

   intarr2[3][3]={{1,2,3},{4,5,6}};

   p=arr2[0];

   int（*pp）[3]=arr2;//虽然二维数组可以理解为一维数组但是不能像上面那样定义一个指针指向它

   //要像这样定义一个指针数组指向2维数组

   pp++;//如果把2维数组看做一个矩阵这相当于移动到下一行

   //指针原本指向{1,2,3}这个元素,现在指向了{4,5,6}

   printf（"%d",*（*pp）+1）;//输出5

}

指向字符串的指针变量

   char*str="sdsdsds";

   printf（"%s",str）;

或者

   char*str;

   str="sdsdsds";

   printf（"%s",str）;

//注意赋给str的不是字符串也不是字符而是字符串的首地址

但是如果换成这样就不行：

   char*str;

   *str="sdsdsds";

   printf（"%s",str）;

字符串指针作为参数（数组复制）

常见做法

#include"stdio.h"

voidcopy_str（charfrom[],chardest[] ）{

   inti=0;

   for（;from[i]!

='\0';i++）

   {

       dest[i]=from[i];

   }

   dest[i]='\0';

}

voidmain（）{

   charfrom[]="sdsdsdfsf";

   chardest[]="dfdsdgfg";

   copy_str（from,dest）;

   printf（"%s",dest）;

}

使用指针作为参数

#include"stdio.h"

voidcopy_str（char*from,char*dest）{

   for（;*from!

='\0';from++,*dest++）

   {

       *dest=*from;

   }

   *dest='\0';

}

voidmain（）{

   charfrom[]="sdsdsdfsf";

   chardest[]="123";

   copy_str（from,dest）;

   printf（"%s",dest）;

}

copy_str中的for循环可以改写为

   while（（*dest=*from）!

='\0'）

   {

       from++;

       dest++;

   }

或者进一步：

   while（（*dest++=*from++）!

='\0'）;

指针的移动

voidmain（）{

   char*a="iloverilakkuma";

   char*p=a+7;//移动指针

   printf（"%s",p）;

   printf（"%c",a[5]）;//虽然没有定义数组a但由于字符串在内存中是以数组的形式存放的

                    //a[5]是按照*（a+5）来执行的

}

输出rilakkumae

指针数组

#include"stdio.h"

voidtestArr（）;

charstr[][5]={"Bill","Sam","Jim","Paul","0"};

//定义了一个数组存放的数组类型是char指针型

//该指针指向一个字符串数组也就是char型的2维数组

char*Names[]=

{

   "Bill",

   "Sam",

   "Jim",

   "Paul",

   "0"

};

voidmain（）

{

   //Names本身是一个指针数组Names是数组名那么代表的是Names数组第一个元素地址

   //*Names就是根据地址区出地址中的内容

   //printf（"%s\n",*（&Names[0]））; //也就是说*Names和*（&Names[0]）一样

   printf（"%s,\n",*Names）;//输出Bill,实际上Names指向的是一个2维数组

   char**p=Names;  //由于Names本身是一个指针数组 想要指向指针数组应定义一个2级指针

   while（*p!

=0）{

       printf（"%s\n",*p）;

       p++;

   }

   *p=Names[0];

   testArr（）;

}

voidtestArr（）{

   intarr1[]={1,2,3};

   int*p=arr1;//这句话拆开应该是int*p;p=arr1 最终p才是指针变量

   intarr2[3][3]={{1,2,3},{4,5,6}};

   p=arr2[0];

   int（*pp）[3]=arr2;//虽然二维数组可以理解为一维数组但是不能像上面那样定义一个指针指向它

   //要像这样定义一个指针数组指向2维数组

   pp++;//如果把2维数组看做一个矩阵这相当于移动到下一行

   //指针原本指向{1,2,3}这个元素,现在指向了{4,5,6}

   printf（"%d",*（*pp）+1）;//输出5

}

示例２

#include"stdio.h"

voidmain（）{

   chararr[]={"123"};//或者是{'1','2','3' };

   charstr[][6]={"i'm","28","year","old","my","dear","u"};//注意要指定高维数组的大小 其长度为该数组最长元素的字符个数+1

   char*p=arr;

   printf（"%c\n",*p）;//输出地址

   while（*p!

='\0'）{

       printf（"%c",*p）;

       p++;

   }

   printf（"\n"）;

   char*name[]={"sss","ddd","ggg"};//不能写成*name[]=str

   char**pp=name;

   printf（"%s\n",*pp）;//输出222

   printf（"%c\n",*（*pp））;//或者简写为printf（"%c\n",**pp）;//输出s

   inti=0;

   while（i<3）

   {

       i++;

       printf（"%s\n",*pp）;

       pp++;

   }

   //**pp两个*的含义

   //如果只有一颗*表示指向字符数据的指针

   //两颗*表示指向字符指针的指针

}

给字符型数组赋值一个字符串

定义一个字符串数组

   charstr[20]="123123";

   charstr2[20]={"123"};

 但是注意不能像下面这样

 charstr[20];

 str="123123";

使用数组的时候，如果在名数组的同时并没有对其初始化，必须要指定该数组的长度，否则系统不知道如何为其分配空间

要么charstr[]="123123";要么chars