C语言字符串处理函数

C语言字符串处理函数

http://blog.csdn.net/ruizeng88/article/details/6677736

 

 

1.字符串比较

int strcmp(const char *s1, const char *s2);

正如有限只字符串的尺寸(不忽视大小写),返回值老有文化:如果s1仅次于s2返回一个小于0的一再,如果s1超过s2返回一个大于0之再三,如果当则赶回回0。返回值是有限独字符串中首先个未等于的字符ascii码的差值。实现如下:

 

[cpp] view
plaincopyprint?

  1. int my_strcmp(const char *s1, const char *s2){  
  2.     //important! validate arguments first!
      
  3.     assert(NULL !=s1 && NULL != s2);  
  4.     while(*s1 != ‘\0’ && *s2 != ‘\0’ && *s1==*s2){  
  5.         s1++;  
  6.         s2++;  
  7.     }  
  8.     return *s1 – *s2;  
  9. }  

    int my_strcmp(const char s1, const char s2){

    //important! validate arguments first!
    assert(NULL !=s1 && NULL != s2);
    while(*s1 != '\0' && *s2 != '\0' && *s1==*s2){
        s1++;
        s2++;
    }
    return *s1 - *s2;
    

    }

在意又函数开始进行参数检查,防止输入参数有NULL时起运行时错。

strcmp是最为常用之字符串比较函数,一般用法是if(!strcmp(s1, s2)){
…}。如果非是对准全体字符串进行较而仅仅是较指定数量的字符串,可以采用函数:

int strncmp(const char *s1, const char *s2, size_t n);

之所以法与归值都和strcmp类似,之较让定字符串的前n个字符,或者到遇到任一字符串结尾。实现如下:

 

[cpp] view
plaincopyprint?

  1. int my_strncmp(const char *s1, const char *s2, size_t n){  
  2.     //important! validate arguments first!
      
  3.     assert(NULL!=s1 && NULL!=s2);  
  4.     if(n == 0)  
  5.         return 0;  
  6.     size_t cnt = 1;  
  7.     while(*s1 != ‘\0’ && *s2 != ‘\0’ && *s1==*s2 && cnt < n){  
  8.         s1++;  
  9.         s2++;  
  10.         cnt++;  
  11.     }  
  12.     return *s1 – *s2;  
  13. }  

    int my_strncmp(const char s1, const char s2, size_t n){

    //important! validate arguments first!
    assert(NULL!=s1 && NULL!=s2);
    if(n == 0)
        return 0;
    size_t cnt = 1;
    while(*s1 != '\0' && *s2 != '\0' && *s1==*s2 && cnt < n){
        s1++;
        s2++;
        cnt++;
    }
    return *s1 - *s2;
    

    }

急需小心的除外参数检查他,还要小心n=0的特殊状况,这里我们n=0永远回回0。

 

 

尚生其它一些拉动特殊要求字符串比较函数,如:

stricmp,memcmp,memicmp等等,加i表示于常疏忽大小写,带mem的凡较相同片内存区间。

2.字符串查找

无限简易的凡寻找字符串查找字符:

char *strchr(const char *s, int c);

有关参数为什么是int,历史遗留问题,这里不多讨论。函数返回在s中找到的率先只c的位置的指针,注意的凡,字符串末尾的‘\0’也是好给搜寻的。实现如下:

[cpp] view
plaincopyprint?

  1. char *my_strchr(const char *s, int n){  
  2.     assert(s != NULL);  
  3.     char c = (char)n;  
  4.     do{  
  5.         if(*s == c)  
  6.             return (char *)s;  
  7.     }while(*s++);  
  8.     return NULL;  
  9. }  

    char my_strchr(const char s, int n){

    assert(s != NULL);
    char c = (char)n;
    do{
        if(*s == c)
            return (char *)s;
    }while(*s++);
    return NULL;
    

    }

还有寻找字符串的函数strstr:

char *strstr(const char *s1, const char *s2);

函数返回s2在s1中出现的首字符的岗位,实现如下:

[cpp] view
plaincopyprint?

  1. char *my_strstr(const char *s1, const char *s2){  
  2.     assert(NULL!=s1 && NULL!=s2);  
  3.     size_t len = strlen(s2);  
  4.     while(*s1){  
  5.         if(!strncmp(s1,s2,len))  
  6.             return (char *)s1;  
  7.         s1++;  
  8.     }  
  9.     return NULL;  
  10. }  

    char my_strstr(const char s1, const char *s2){

    assert(NULL!=s1 && NULL!=s2);
    size_t len = strlen(s2);
    while(*s1){
        if(!strncmp(s1,s2,len))
            return (char *)s1;
        s1++;
    }
    return NULL;
    

    }

c标准库中并没有定义类似strnchr和strnstr的界定查找范围之函数,当然需要的话我们好团结定义,如:

[cpp] view
plaincopyprint?

  1. char *strnstr(const char* s1, const char* s2, size_t n)  
  2. {  
  3.   const char* p;  
  4.   size_t len = strlen(s2);  
  5.   if (len == 0) {  
  6.     return (char *)s1;  
  7.   }  
  8.   for (p = s1; *p && (p + len<= buffer + n); p++) {  
  9.     if ((*p == *token) && (strncmp(p, token, tokenlen) == 0)) {  
  10.       return (char *)p;  
  11.     }  
  12.   }  
  13.   return NULL;  
  14. }  

    char strnstr(const char s1, const char s2, size_t n)
    {
    const char
    p;
    size_t len = strlen(s2);
    if (len == 0) {

    return (char *)s1;
    

    }
    for (p = s1; *p && (p + len<= buffer + n); p++) {

    if ((*p == *token) && (strncmp(p, token, tokenlen) == 0)) {
      return (char *)p;
    }
    

    }
    return NULL;
    }

3.字符串复制

尽常见的字符串复制函数是strcpy:

char *strcpy(char *dst, const char *src);

管src所因的由NULL结尾的字符串复制到由dst所指的字符串中,src和dst不得以同(可以由c99的restrict关键字声明),dst必出足的长空存放复制的字符串。

再有少数如留心的是函数返回值,返回值是据为dst的指针,这样做的目的是好程序中报告句内联,比如strlen(strcpy(s,t))。

函数的实现如下:

[cpp] view
plaincopyprint?

  1. char *my_strcpy(char *dst, const char *src){  
  2.     assert(NULL!=dst && NULL!=src);  
  3.     char *p = dst;  
  4.     while((*dst++ = *src++) != ‘\0’);  
  5.     return p;  
  6. }  

    char my_strcpy(char dst, const char *src){

    assert(NULL!=dst && NULL!=src);
    char *p = dst;
    while((*dst++ = *src++) != '\0');
    return p;
    

    }

应用strcpy是危在旦夕的,因为函数本身是未检查dst指向的上空是否足够存储需要复制的字符串,导致的一个神秘隐患就是字符串溢起。这也是上个世纪常叫黑客利用的一个经漏洞。所以,在大部情景下都是为此strncpy无疑更加保险:

[cpp] view
plaincopyprint?

  1. char *my_strncpy(char *dst, const char *src, size_t n){  
  2.     assert(NULL!=dst && NULL!=src);  
  3.     char *p = dst;  
  4.     while(n){  
  5.         if((*dst++ = *src++) == ‘\0’)  
  6.             break;  
  7.         n–;  
  8.     }  
  9.     return p;  
  10. }  

    char my_strncpy(char dst, const char *src, size_t n){

    assert(NULL!=dst && NULL!=src);
    char *p = dst;
    while(n){
        if((*dst++ = *src++) == '\0')
            break;
        n--;
    }
    return p;
    

    }

亟需留意另外一个函数strdup:

char *strdup(const char *);

拖欠函数和strcpy的不同是,函数会好报名内存空间存放拷贝的字符串,然后回指于该字符串的指针。所以在采用strdup函数时用注意的凡,在运用了复制的字符串后采取free函数释放其占据的半空中。

任何memcpy函数和strncpy类似,只是不会见再也相见NULL时已拷贝,该函数一定会拷贝n个字符。

 

4.字符串连接

字符串连接是管一个字符串的头连接到其他一个字符串的末段。

char *strcat(char *s1, const char *s2);

函数的实现如下:

[cpp] view
plaincopyprint?

  1. char *my_strcat(char *s1, const char *s2){  
  2.     assert(NULL!=s1 && NULL!=s2);  
  3.     char *p =s1;  
  4.     while(*s1)s1++;  
  5.     strcpy(s1,s2);  
  6.     return p;  
  7. }  

    char my_strcat(char s1, const char *s2){

    assert(NULL!=s1 && NULL!=s2);
    char *p =s1;
    while(*s1)s1++;
    strcpy(s1,s2);
    return p;
    

    }

一样,strcat也是休安全之,因为也对缓冲区足够存放连接的字串进行了如果。所以,多数动静下我们相应下还安全的:

char *strncat(char *s1, const char *s2, size_t n

 


 

分拣自己欲之资料,慢慢爬行

C语言中之字符串截取函数和采取

/*========================================================

对此一个五位数a1a2a3a4a5,可拿那个拆分为三只子数:
sub1=a1a2a3
sub2=a2a3a4
sub3=a3a4a5
比如说,五员数20207足拆分成
sub1=202
sub2=020(=20)
sub3=207
今加以一个正整数K,要求你编程求出10000届30000之间具有满足下述条件的五各数,
标准是这些五个数之老三只子数sub1,sub2,sub3且可为K整除。
输入
输入由键盘输入,输入才一行,为正整数K(0<K<1000)。
输出
输出到文件,输出文件之各一样行为一个满足条件的五员数,要求自小至十分出口。
不行重复输出或漏。如果无解,则输出“No”。

样例
num.in
15
num.out
22555
25555
28555
30000

==========================================================*/

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

/*打字符串的左截取n个字符*/
char * left(char *dst,char *src, int n)
{
    char *p = src;
    char *q = dst;
    int len = strlen(src);
    if(n>len) n = len;
    /*p += (len-n);*/   /*起右边第n独字符开始*/
    while(n–) *(q++) = *(p++);
    *(q++)=’\0′; /*来必不可少吗?很有必不可少*/
    return dst;
}

/*自打字符串的中游截取n个字符*/
char * mid(char *dst,char *src, int
n,int m) /*n为长度,m为位置*/
{
    char *p = src;
    char *q = dst;
    int len = strlen(src);
    if(n>len) n = len-m;    /*从今第m只至最终*/
    if(m<0) m=0;    /*从第一独开始*/
    if(m>len) return NULL;
    p += m;
    while(n–) *(q++) = *(p++);
    *(q++)=’\0′; /*产生必不可少为?很有必要*/
    return dst;
}

/*由字符串的右侧截取n个字符*/
char * right(char *dst,char *src, int
n)
{
    char *p = src;
    char *q = dst;
    int len = strlen(src);
    if(n>len) n = len;
    p += (len-n);   /*打右边第n独字符开始*/
    while(*(q++) = *(p++));
    return dst;
}

void main()
{
    FILE * p;
    int i,k,outi,count=0;
    int sub1,sub2,sub3;
    char *strsub1,*strsub2,*strsub3,*strtempnum,*a,*b,*c;

    if((p = fopen(“num.out”, “ab+”)) == NULL)
    {
        printf(“open file fail!”);
        getch();
        exit();
    }
    printf(“Please input int number(0<K<1000):”);
    scanf(“%d”,&k);

    for(outi=10000;outi<=30000;outi++)
    {
        itoa(outi,strtempnum,10);

        left(strsub1,strtempnum,3);
        mid(strsub2,strtempnum,3,1);
        right(strsub3,strtempnum,3);

        /*
        a=strsub1;
        b=strsub2;
        c=strsub3;
        printf(“strsub1=%s,strsub2=%s,strsub3=%s\n”,a,b,c);
        */

        sub1=atoi(strsub1);
        sub2=atoi(strsub2);
        sub3=atoi(strsub3);

        /*
        printf(“sub1=%d , sub2=%d , sub3=%d \n\n”,sub1,sub2,sub3);
        printf(“sub1k=%d , sub2k=%d , sub3k=%d \n\n” , sub1 % k,sub2 %
k,sub3 % k);
        getch();
        */
        if((sub1%k)==0 && (sub2%k)==0 && (sub3%k)==0)
        {
            fprintf(p,”%d\n”,outi);
            count++;
            printf(“outi=%d\n”,outi);
        }
        else
        {
            fprintf(p,”%s\n”,”NO”);
        }
    }
    printf(“Count=%d    OK”,count);
    fclose(p);
    getch();
}

 http://www.cnblogs.com/rosesmall/archive/2012/03/27/2420335.html