精华内容
下载资源
问答
  • 本人写了个拷贝字符串函数(即实现函数strcpy()),欢迎各位拍砖。 char *strcpy(char *strDest, const char *strSrc) { assert((strDest!=NULL)&&(strSrc!=NULL)); char *address=strDest; ...
  • 字符函数和字符串函数 求字符串长度 strlen 长度不受限制的字符串函数 strcpy -字符串拷贝 strcat - 字符串追加 strcmp- 字符串比较 字符串查找 strstr - 查找子字符串 strtok字符串分割 错误信息报告 strerror 字符...

    字符函数和字符串函数

    求字符串长度 strlen
    长度不受限制的字符串函数
    strcpy -字符串拷贝
    strcat - 字符串追加
    strcmp- 字符串比较
    字符串查找
    strstr - 查找子字符串
    strtok字符串分割
    错误信息报告
    strerror
    字符操作
    内存操作函数
    memcpy
    memove
    memset
    memcmp

    函数介绍

    strlen
    size_t strlen(const char* str);
    字符串已经’\0’作为结束标志、strlen函数返回的是在字符串中’\0’前面出现的字符个数(不包含‘\0’)。
    参数指向的字符必须要以’\0’。
    注意函数的返回值size_t,是无符号的。
    strlen 函数的实现(3种)

    size_t my_strlen(const char* str)
    {	int count = 0;
    	assert(str != NULL);
    	while (*str != '\0')
    	{
    	count++;
    	str++;
    	}	
    	return count;
    }

    ②递归

    size_t my_strlen(const char* str)
    {
     assert(*str!=NULL);
      if (*str != '\0')
      {
      return 1 + my_strlen(str + 1);
      } 
      else  
      return 0;
     }`
    

    ③指针-指针

    size_t my_strlen(const char* str)
    {	
    const char *start = str;	
    while (*str != '\0')	
    {		
    str++;	
    }	
    return str - start;
    }

    strcpy
    char* strcpy(char * destination,const char *source);
    源字符串必须以’\0’ 结尾
    会将字符串中的 ‘\0’ 拷贝到自己的空间
    目标空间必须足够大,以确保能存放源字符串
    目标空间必须可变

    strcpy函数实现

    char* my_strcpy(char *arr1, const char* arr2)
    {	
    char* ret = arr1;	
    assert(arr1 != NULL);	
    assert(arr2 != NULL);	
    while (*(arr1++) = *(arr2++))	
    {		
    ;	
    }	
    return ret;
    }

    strcat
    char* strcat(cosnt char *str1,const char *str2);
    源字符串必须以’\0’ 结尾
    目标空间必须足够大,以确保能存放源字符串
    目标空间必须可修改
    字符串不能自己给自己追加

    strcat函数的实现

    char* my_strcat(char *dest, const char  *src)
    {	
    char*ret = dest;	
    assert(dest);	
    assert(src);	
    while (*dest)	
    {	
      dest++;	
      }	
      while (*dest++ = *src++)	
      {		
      ;	
      }
      return ret;
      }

    strcmp
    int strcmp(const char * str1,const char *str2);
    标准规定:
    第一个字符串大于第二个字符串,则返回大于0的数字
    第一个字符串等于第二个字符串,则返回0
    第一个字符串小于第二个字符串,则返回小于0的数字

    strcmp函数的实现

    int my_strcmp(const char*s1, const char*s2)
    {	
    assert(s1);	
    assert(s2);	
    while (*s1 == *s2)
    {	
    	if (*s1 == '\0')
    	return 0;		
    	s1++;		
    	s2++;		
    	return *s1 - *s2;	
    	}
    }

    strstr
    char *strstr( const char * str1,const char * str2);

    strstr 函数实现

    char* my_strstr(const char*str1, const char*str2)
    {	
    assert(str1);
    assert(str2);	
    const char *s1 = str1;	
    const char *s2 = str2;	
    const char *cp = str1;	
    if (*s2 == '\0')	
    {		
    return (char *)str1;	
    }	
    while (*cp)	
    {		
    s1 = cp;		
    s2 = str2;		
    while (*s1&&*s2&&*s1 == *s2)		
    {		
    
    s1++;		
    s2++;	
    }	
    if (*s2 == '\0')		
    {			
    return (char*)cp;		
    }		
    cp++;	
    }	
    return NULL;
    }

    strtok
    char * strtok ( char * str, const char * sep );

    sep参数是个字符串,定义了用作分隔符的字符集合

    第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
    strtok函数找到str中的下一个标记,并将其用 \0 结尾,返回一个指向这个标记的指针。(注:strtok函数会改
    变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。)
    strtok函数的第一个参数不为 NULL ,函数将找到str中第一个标记,strtok函数将保存它在字符串中的位置。
    strtok函数的第一个参数为 NULL ,函数将在同一个字符串中被保存的位置开始,查找下一个标记。
    如果字符串中不存在更多的标记,则返回 NULL 指针

    memcpy
    void * memcpy ( void * destination, const void * source, size_t num);

    函数memcpy从src位置开始向后的num个字节复制到dst的内存位置。
    这个函数遇到’\0’的时候并不会停下来。
    源内存块和目标内存块重叠时,复制结果是未定义的。
    memcpy函数的模拟实现

    void *memcpy(void* dest, const void* src, size_t num)
    {
     void* ret = dest;
     assert(dest != NULL);
     assert(src != NULL);
     while (num--)
     {
      *(char* )dest = *(char*)src;
      ((char*)dest)++;
      ((char*)src)++;
     }
     return ret;
    }
    

    memmove

    ==void * memmove ( void * destination, const void * source, size_t num ); ==

    和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
    如果源空间和目标空间出现重叠,就得使用memmove函数处理。

    memmove函数的实现

    void* my_memmove(void* dest, const void* src, size_t count)
    {
     assert(dest);
     assert(src);
     if (dest < src)
     {
      //前->后
      while (count--)
      {
       *(char*)dest = *(char*)src;
       dest = (char*)dest + 1;
       src = (char*)src + 1;
      }
     }
     else
     {
      //后->前
      while (count--)
      {
       *((char*)dest + count) = *((char*)src + count);
      }
     }
    }
    
    展开全文
  • C语言:拷贝函数拷贝字符串

    千次阅读 2018-10-20 21:56:50
    #include&lt;stdio.h&gt;...//拷贝函数拷贝字符串 //方法一: char * My_strcpy1(char *dest,const char *src) { char *p = dest; assert(dest != NULL &amp;&amp; src != NU...
    #include<stdio.h>
    #include<string.h>
    #include<assert.h>
    //拷贝函数拷贝字符串
    
    //方法一:
    char * My_strcpy1(char *dest,const char *src)
    {
    	char *p = dest;
    	assert(dest != NULL && src != NULL);
    	while(*dest++ = *src++) {}
    	
    	return p;
    }
    
    //方法二:
    char * My_strcpy2(char *dest,const char *src)
    {
    	char *p = dest;
    	assert(dest != NULL && src != NULL);//断言指针不能为0
    	while(*src != '\0')
    	{
    		*dest = *src;//src指针的指向值赋给指针dest
    		dest++;
    		src++;
    	}
    	return p;
    }
    //方法一比方法二更优化
    int main()
    {
    	
    	char *str2 = "hello";
    	char str3[6] = {};
    	char *p = My_strcpy2(str3,str2);//str2中的字符串拷贝给str3
    	printf("%s\n",p);
    	
    	getchar();
    	return 0;
    }
    

    答案:hello

    展开全文
  • 长度受限的字符串函数 一、strncpy函数 char* strncpy(char *dest,const char *src,size_t num); 功能:拷贝num个字符从源字符串到目标空间 规定: 如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后面...

    长度受限的字符串函数

    一、strncpy函数
    char* strncpy(char *dest,const char *src,size_t num);
    功能:拷贝num个字符从源字符串到目标空间
    规定:

    • 如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后面追加0,直到num个。
      1、strncpy函数模拟实现
    #define _CRT_SECURE_NO_WARNINGS 1
    #include <stdio.h>
    #include <Windows.h>
    #include <assert.h>
    //strncpy函数模拟实现
    void my_strncpy(char *dest, const char* src, int num){
    	assert(dest!=NULL);//判断是否为空指针,如果为空指针则打印错误信息
    	assert(src != NULL);
    	int i = 1;
    	for (i = 1; i <= num; i++){//判断src的长度是否小于需要拷贝的字符长度
    		if (*src == '\0'){//当src的长度小于需要拷贝的字符长度,则在后面补'\0'
    			*dest = '\0';
    			dest++;
    		}
    		else{
    			*dest = *src;//把src的字符复制到目标空间
    			dest++;
    			src++;
    		}
    	}
    }
    int main(){
    	char arr1[NUM] = "abcdef";
    	char arr2[] = "weqtqwe";
    	 my_strncpy(arr1, arr2,4);
    	printf("%s", arr1);
    	system("pause");
    	return 0;
    }
    

    2、库函数实现strncpy方法

    char * __cdecl strncpy (
            char * dest,
            const char * source,
            size_t count
            )
    {
            char *start = dest;
    
            while (count && (*dest++ = *source++))    /* copy string */
                    count--;
    
            if (count)                              /* pad out with zeroes */
                    while (--count)
                            *dest++ = '\0';
    
            return(start);
    }
    
    

    二、strncat函数
    char *strncat(char *dest, const char *src,size_t num);
    功能:将源字符串中的前num个字符追加到目标空间去,最后补上一个’\0’
    规定:在源字符串长度小于num时,把源字符串追加到目标空间后补个’\0’即可。
    1、strncat函数实现

    #define _CRT_SECURE_NO_WARNINGS 1
    #include <stdio.h>
    #include <Windows.h>
    #include <assert.h>
    //strncat函数模拟实现
    void my_strncat(char* dest, const char *src, int num){
    	assert(dest);//判断是否为空指针
    	assert(src);
    	while (*dest != '\0'){//挪到目标空间的最后面
    		dest++;
    	}
    	while (num && (*src != '\0')){//判断源字符串的长度是否小于追加字符长度
    		*dest = *src;
    		dest++;
    		src++;
    		num--;
    	}
    	if (*src == '\0'){//当源字符串长度小于追加字符长度,追加'\0',然后结束strncat函数
    		*dest = *src;
    	}
    }
    int main(){
    	char arr1[NUM] = "abcdef";
    	char arr2[] = "weqtqwe";
    	 my_strncat(arr1, arr2,4);
    	printf("%s", arr1);
    	system("pause");
    	return 0;
    }
    

    2、库函数实现方法

    char * __cdecl strncat (
            char * front,
            const char * back,
            size_t count
            )
    {
            char *start = front;
    
            while (*front++)
                    ;
            front--;
    
            while (count--)
                    if (!(*front++ = *back++))
                            return(start);
    
            *front = '\0';
            return(start);
    }
    

    三、strncmp函数
    strncmp(const char* str1,const char* str2,int num);
    功能:比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
    规定:

    • 前num个字符相等就返回0
    • str1比str2字符大则返回大于0的数
    • str1比str2字符小则返回小于0的数
    • 比较的不是字符串长度!而是字符的ascii码值。
      1、strncmp函数模拟实现
    #define _CRT_SECURE_NO_WARNINGS 1
    #include <stdio.h>
    #include <Windows.h>
    #include <assert.h>
    //strncmp函数模拟实现
    int my_strncmp(const char* str1, const char *str2, int num){
    	assert(str1);
    	assert(str2);
    	while (num && (*str1 == *str2)){//比较源字符串和目标字符串前num个字符
    		num--;
    		str1++;
    		str2++;
    	}
    	if (num == 0){//如果前num字符完全相等,则返回0
    		return 0;
    	}
    	else {
    		return *str1 - *str2;//如果不相等,则返回第一个字符减去第二个字符的值
    	}
    }
    int main(){
    	char arr1[] = "abcdef";
    	char arr2[] = "abcaqwe";
    	int ret =  my_strncmp(arr1, arr2,4);
    	printf("%d", ret);
    	system("pause");
    	return 0;
    }
    

    2、库函数实现方式

    int __cdecl strncmp
    (
        const char *first,
        const char *last,
        size_t      count
    )
    {
        size_t x = 0;
    
        if (!count)
        {
            return 0;
        }
    
        /*
         * This explicit guard needed to deal correctly with boundary
         * cases: strings shorter than 4 bytes and strings longer than
         * UINT_MAX-4 bytes .
         */
        if( count >= 4 )
        {
            /* unroll by four */
            for (; x < count-4; x+=4)
            {
                first+=4;
                last +=4;
    
                if (*(first-4) == 0 || *(first-4) != *(last-4))
                {
                    return(*(unsigned char *)(first-4) - *(unsigned char *)(last-4));
                }
    
                if (*(first-3) == 0 || *(first-3) != *(last-3))
                {
                    return(*(unsigned char *)(first-3) - *(unsigned char *)(last-3));
                }
    
                if (*(first-2) == 0 || *(first-2) != *(last-2))
                {
                    return(*(unsigned char *)(first-2) - *(unsigned char *)(last-2));
                }
    
                if (*(first-1) == 0 || *(first-1) != *(last-1))
                {
                    return(*(unsigned char *)(first-1) - *(unsigned char *)(last-1));
                }
            }
        }
    
        /* residual loop */
        for (; x < count; x++)
        {
            if (*first == 0 || *first != *last)
            {
                return(*(unsigned char *)first - *(unsigned char *)last);
            }
            first+=1;
            last+=1;
        }
    
        return 0;
    }
    
    

    库函数实现方式是四个字节一比,应该是为了效率高低问题,也没找到相关的文章专门说明这个,如果哪位兄台看见我这篇文章,希望能帮忙解答一下!感激不尽!
    四、strstr函数
    char* strstr(const char* str1,const char* str2);
    功能:找子串,如果找到则把子串开始的第一个字符的地址传回主函数。
    1、strstr函数模拟实现

    #define _CRT_SECURE_NO_WARNINGS 1
    #include <stdio.h>
    #include <Windows.h>
    #include <assert.h>
    //strstr函数模拟实现
    char* my_strstr(const char* p1, const char* p2){
    	assert(p1);//判断是否为空指针
    	assert(p2);
    	//s1、s2是用来移动比较字符的
    	char *s1 =(char*) p1;//把p1强制转换为char*类型,不然因为p1是const,程序会出现警告
    	char *s2 = (char*)p2;//p2同理
    	char *cur = p1;//cur是用来记录字符串匹配的起点
    	while (*cur){
    		s1 = cur;
    		s2 = p2;
    		while (*s1&&*s2 && (*s1 == *s2)){
    			s1++;
    			s2++;
    		}
    		if ((*s1 == '\0')&&*s2){//目的字符串找到了最后一个字符,但是s2没有完全匹配,则无该字串
    			printf("没有匹配的子串");
    			return NULL;
    		}
    		else if (*s2 == '\0'){//在目标字符串中找到了源字符串
    			return cur;
    		}
    		else{
    			cur++;//没有匹配上,cur往后 走一个字符,重新开始匹配
    		}
    	}
    }
    int main(){
    	char arr1[] = "abbbcdef";
    	char arr2[] = "bbc";
    	char* ret =  my_strstr(arr1, arr2);
    	printf("%s", ret);
    	system("pause");
    	return 0;
    }
    

    2、库函数源码实现过程

    char * __cdecl strstr (
            const char * str1,
            const char * str2
            )
    {
            char *cp = (char *) str1;
            char *s1, *s2;
    
            if ( !*str2 )
                return((char *)str1);
    
            while (*cp)
            {
                    s1 = cp;
                    s2 = (char *) str2;
    
                    while ( *s1 && *s2 && !(*s1-*s2) )
                            s1++, s2++;
    
                    if (!*s2)
                            return(cp);
    
                    cp++;
            }
    
            return(NULL);
    
    }
    

    五、strtok函数*(了解如何使用即可)*
    char * strtok(char* str,const char* sep);
    sep参数是个字符串,定义了用作分隔符的字符串集合
    规定:

    • 第一个参数指定一个字符串,它包括了0个或者多个由sep字符串中的一个或者多个分隔符分割的标记。
    • strtok函数找到str的下一个标记,并将其用\0结尾,返回一个指向这个标记的指针。(注:strtok函数会改变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。
    • strtok函数的第一个参数不为NULL,函数将找到str中的第一个标记,strtok函数将保存它在字符串中的位置。
    • strtok函数的第一个参数为NULL,函数将在同一字符串中被保存的位置开始,查找下一标记。
    • 如果字符串中不存在更多的标记,则返回NULL指针。

    1、库函数源码实现过程

    har * __cdecl strtok (
            char * string,
            const char * control
            )
    #endif  /* _SECURE_VERSION */
    {
            unsigned char *str;
            const unsigned char *ctrl = control;
    
            unsigned char map[32];
            int count;
    
    #ifdef _SECURE_VERSION
    
            /* validation section */
            _VALIDATE_RETURN(context != NULL, EINVAL, NULL);
            _VALIDATE_RETURN(string != NULL || *context != NULL, EINVAL, NULL);
            _VALIDATE_RETURN(control != NULL, EINVAL, NULL);
    
            /* no static storage is needed for the secure version */
    
    #else  /* _SECURE_VERSION */
    
            _ptiddata ptd = _getptd();
    
    #endif  /* _SECURE_VERSION */
    
            /* Clear control map */
            for (count = 0; count < 32; count++)
                    map[count] = 0;
    
            /* Set bits in delimiter table */
            do {
                    map[*ctrl >> 3] |= (1 << (*ctrl & 7));
            } while (*ctrl++);
    
            /* Initialize str */
    
            /* If string is NULL, set str to the saved
             * pointer (i.e., continue breaking tokens out of the string
             * from the last strtok call) */
            if (string)
                    str = string;
            else
                    str = _TOKEN;
    
            /* Find beginning of token (skip over leading delimiters). Note that
             * there is no token iff this loop sets str to point to the terminal
             * null (*str == '\0') */
            while ( (map[*str >> 3] & (1 << (*str & 7))) && *str )
                    str++;
    
            string = str;
    
            /* Find the end of the token. If it is not the end of the string,
             * put a null there. */
            for ( ; *str ; str++ )
                    if ( map[*str >> 3] & (1 << (*str & 7)) ) {
                            *str++ = '\0';
                            break;
                    }
    
            /* Update nextoken (or the corresponding field in the per-thread data
             * structure */
            _TOKEN = str;
    
            /* Determine if a token has been found. */
            if ( string == str )
                    return NULL;
            else
                    return string;
    }
    

    六、strerror函数 (了解如何使用即可)
    char* strerror(int errnum);
    功能:返回错误码,所对应的错误信息。

    以下来自linux 2.4.20-18的内核代码中的/usr/include/asm/errno.h
    #ifndef _I386_ERRNO_H
    #define _I386_ERRNO_H
    #define EPERM 1 /* Operation not permitted */
    #define ENOENT 2 /* No such file or directory */
    #define ESRCH 3 /* No such process */
    #define EINTR 4 /* Interrupted system call */
    #define EIO 5 /* I/O error */
    #define ENXIO 6 /* No such device or address */
    #define E2BIG 7 /* Arg list too long */
    #define ENOEXEC 8 /* Exec format error */
    #define EBADF 9 /* Bad file number */
    #define ECHILD 10 /* No child processes */
    #define EAGAIN 11 /* Try again */
    #define ENOMEM 12 /* Out of memory */
    #define EACCES 13 /* Permission denied */
    #define EFAULT 14 /* Bad address */
    #define ENOTBLK 15 /* Block device required */
    #define EBUSY 16 /* Device or resource busy */
    #define EEXIST 17 /* File exists */
    #define EXDEV 18 /* Cross-device link */
    #define ENODEV 19 /* No such device */
    #define ENOTDIR 20 /* Not a directory */
    #define EISDIR 21 /* Is a directory */
    #define EINVAL 22 /* Invalid argument */
    #define ENFILE 23 /* File table overflow */
    #define EMFILE 24 /* Too many open files */
    #define ENOTTY 25 /* Not a typewriter */
    #define ETXTBSY 26 /* Text file busy */
    #define EFBIG 27 /* File too large */
    #define ENOSPC 28 /* No space left on device */
    #define ESPIPE 29 /* Illegal seek */
    #define EROFS 30 /* Read-only file system */
    #define EMLINK 31 /* Too many links */
    #define EPIPE 32 /* Broken pipe */
    #define EDOM 33 /* Math argument out of domain of func */
    #define ERANGE 34 /* Math result not representable */
    #define EDEADLK 35 /* Resource deadlock would occur */
    #define ENAMETOOLONG 36 /* File name too long */
    #define ENOLCK 37 /* No record locks available */
    #define ENOSYS 38 /* Function not implemented */
    #define ENOTEMPTY 39 /* Directory not empty */
    #define ELOOP 40 /* Too many symbolic links encountered */
    #define EWOULDBLOCK EAGAIN /* Operation would block */
    #define ENOMSG 42 /* No message of desired type */
    #define EIDRM 43 /* Identifier removed */
    #define ECHRNG 44 /* Channel number out of range */
    #define EL2NSYNC 45 /* Level 2 not synchronized */
    #define EL3HLT 46 /* Level 3 halted */
    #define EL3RST 47 /* Level 3 reset */
    #define ELNRNG 48 /* Link number out of range */
    #define EUNATCH 49 /* Protocol driver not attached */
    #define ENOCSI 50 /* No CSI structure available */
    #define EL2HLT 51 /* Level 2 halted */
    #define EBADE 52 /* Invalid exchange */
    #define EBADR 53 /* Invalid request descriptor */
    #define EXFULL 54 /* Exchange full */
    #define ENOANO 55 /* No anode */
    #define EBADRQC 56 /* Invalid request code */
    #define EBADSLT 57 /* Invalid slot */
    #define EDEADLOCK EDEADLK
    #define EBFONT 59 /* Bad font file format */
    #define ENOSTR 60 /* Device not a stream */
    #define ENODATA 61 /* No data available */
    #define ETIME 62 /* Timer expired */
    #define ENOSR 63 /* Out of streams resources */
    #define ENONET 64 /* Machine is not on the network */
    #define ENOPKG 65 /* Package not installed */
    #define EREMOTE 66 /* Object is remote */
    #define ENOLINK 67 /* Link has been severed */
    #define EADV 68 /* Advertise error */
    #define ESRMNT 69 /* Srmount error */
    #define ECOMM 70 /* Communication error on send */
    #define EPROTO 71 /* Protocol error */
    #define EMULTIHOP 72 /* Multihop attempted */
    #define EDOTDOT 73 /* RFS specific error */
    #define EBADMSG 74 /* Not a data message */
    #define EOVERFLOW 75 /* Value too large for defined data type */
    #define ENOTUNIQ 76 /* Name not unique on network */
    #define EBADFD 77 /* File descriptor in bad state */
    #define EREMCHG 78 /* Remote address changed */
    #define ELIBACC 79 /* Can not access a needed shared library */
    #define ELIBBAD 80 /* Accessing a corrupted shared library */
    #define ELIBSCN 81 /* .lib section in a.out corrupted */
    #define ELIBMAX 82 /* Attempting to link in too many shared libraries */
    #define ELIBEXEC 83 /* Cannot exec a shared library directly */
    #define EILSEQ 84 /* Illegal byte sequence */
    #define ERESTART 85 /* Interrupted system call should be restarted */
    #define ESTRPIPE 86 /* Streams pipe error */
    #define EUSERS 87 /* Too many users */
    #define ENOTSOCK 88 /* Socket operation on non-socket */
    #define EDESTADDRREQ 89 /* Destination address required */
    #define EMSGSIZE 90 /* Message too long */
    #define EPROTOTYPE 91 /* Protocol wrong type for socket */
    #define ENOPROTOOPT 92 /* Protocol not available */
    #define EPROTONOSUPPORT 93 /* Protocol not supported */
    #define ESOCKTNOSUPPORT 94 /* Socket type not supported */
    #define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
    #define EPFNOSUPPORT 96 /* Protocol family not supported */
    #define EAFNOSUPPORT 97 /* Address family not supported by protocol */
    #define EADDRINUSE 98 /* Address already in use */
    #define EADDRNOTAVAIL 99 /* Cannot assign requested address */
    #define ENETDOWN 100 /* Network is down */
    #define ENETUNREACH 101 /* Network is unreachable */
    #define ENETRESET 102 /* Network dropped connection because of reset */
    #define ECONNABORTED 103 /* Software caused connection abort */
    #define ECONNRESET 104 /* Connection reset by peer */
    #define ENOBUFS 105 /* No buffer space available */
    #define EISCONN 106 /* Transport endpoint is already connected */
    #define ENOTCONN 107 /* Transport endpoint is not connected */
    #define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */
    #define ETOOMANYREFS 109 /* Too many references: cannot splice */
    #define ETIMEDOUT 110 /* Connection timed out */
    #define ECONNREFUSED 111 /* Connection refused */
    #define EHOSTDOWN 112 /* Host is down */
    #define EHOSTUNREACH 113 /* No route to host */
    #define EALREADY 114 /* Operation already in progress */
    #define EINPROGRESS 115 /* Operation now in progress */
    #define ESTALE 116 /* Stale NFS file handle */
    #define EUCLEAN 117 /* Structure needs cleaning */
    #define ENOTNAM 118 /* Not a XENIX named type file */
    #define ENAVAIL 119 /* No XENIX semaphores available */
    #define EISNAM 120 /* Is a named type file */
    #define EREMOTEIO 121 /* Remote I/O error */
    #define EDQUOT 122 /* Quota exceeded */
    #define ENOMEDIUM 123 /* No medium found */
    #define EMEDIUMTYPE 124 /* Wrong medium type */
    #endif
    
    展开全文
  • 字符串函数 strlen size_t strlen (const char *str); 返回字符串的长度,'\0'结束,不包括'\0' strcpy char* strcpy (char* detination, const cahr* source); 拷贝字符串,源字符串以'\0'结束,而且'\0'也...

    字符函数

    字符分类函数

    字符串函数

    strlen

    • size_t strlen (const char *str);
    • 返回字符串的长度,'\0'结束,不包括'\0'

    strcpy

    • char* strcpy (char* detination, const cahr* source);
    • 拷贝字符串,源字符串以'\0'结束,而且'\0'也拷贝,拷贝失败返回detination

    strcat

    • char* strcat (char* destination, const char* source);
    • 将源字符串追加到目的字符串后,源字符串必须以'\0'结束,目的字符串必须有足够大的空间并可以修改,追加失败返回detination

    strcmp

    • int strcmp (const char* str1, const char* str2);
    • 从第一个字符开始比较每一个字符,直到出现不一样的字符或'\0',str1大于str2返回大于0的数,等于返回0,小于返回小于0的数

    strncpy

    • char* strncpy (char* destination, const char* sourse, size_t num);
    • 拷贝num个字符从源字符串到目标空间,如果源字符串长度小于num,则拷贝完成后在后面追加0,拷贝失败返回detination

    strncat

    • char* strncat (char* destination, const char* sourse, size_t num);
    • 将num个源字符串的字符追加到目的字符串后,目的字符串必须有足够大的空间,如果num大于源字符串的长度,则只复制到'\0',追加失败返回detination

    strncmp

    • int strncmp (const char* str1, const char* str2, size_t num);
    • 从第一个字符开始比较每一个字符,直到出现不一样的字符或'\0'或num个字符,str1大于str2返回大于0的数,等于返回0,小于返回小于0的数

    strchr

    • char* strchr (const char* str, int character);
    • 查找字符串中字符第一次出现,返回该字符的地址,不存在则返回NULL

    strrchr

    • char* strrchr (const char* str, int character);
    • 查找字符串中字符最后出现,找到返回该字符的地址,不存在则返回NULL

    strpbrk

    • char* strpbrk (const char* str1, const char* str2);
    • 在字符串str1中寻找字符串str2中任何一个字符匹配,不包括'\0',找到返回第一个字符的地址,没找到返回NULL

    strstr

    • char* strstr (const char* str1, const char* str2);
    • 查找str2在str1第一次出现,找到返回第一次匹配点的地址,没找到返回NULL
    • strspn
    • size_t strspn (const char* str1, const char* str2);
    • 返回str1中第一个不在str2出现的字符下标

    strcspn

    • size_t strcspn (const char* str1, const char* str2);
    • 在字符串str1中寻找字符串str2中任何一个字符匹配,包括'\0',找到返回第一个字符的下标

    strtok

    • char* strtok (char* str, const char* delimiters);
    • str中包含0个或多个由delimiters中的字符,以这些字符为标记,通过strtok函数找到str中的下一个标记,将其用'\0'结尾,返回指向这个标记的指针;若第一个参数不为NULL,函数将找到str中第一个标记,strtok保存它在字符串中的位置;当第一个参数为NULL时,函数将在同一个字符串中被保存的位置开始查找下一个标记;字符串不存在更多的标记,则返回NULL

    strerror

    • char* strerror (int errnum);
    • 返回错误码所对应的错误信息

    memcpy

    • void* memcpy (void* destination, const void* sourse, size_t num);
    • 从sourse内存地址起始位置开始拷贝大小为num的内存块到目标destination所指的内存地址的起始位置中并返回destination,遇到'\0'不会停下来;如果sourse和destination所指内存区域有重叠,则重叠区域结果未定义

    memmove

    • void* memmove (void* destination, const void* sourse, size_t num);
    • memove与memcpy功能相同都是内存块的拷贝,不同的是memmove可以处理destination与sourse内存的重叠

    memset

    • void* memset (void* ptr, int value, size_t num);
    • 将ptr的前num个字节用vlaue替换并返回ptr

    memcmp

    • int memcmp (const void* ptr1, const void* ptr2, size_t num);
    • 比较ptr1和ptr2开始的num个字节,ptr1大于ptr2返回大于0的数,等于返回0,小于返回小于0的数

    memchr

    • void* memchr (const void* ptr, int value, size_t num);
    • 在ptr所指内存区域的前num个字节查找第一次出现的字符value,找到返回字符的地址,没找到返回NULL

    模拟strlen、strcpy、strcat、strcmp、strncpy、strncat、strncmp、strchr、strstr、memcpy、memmove的实现

    展开全文
  • 字符函数和字符串函数函数介绍求字符串长度strlen-获取字符串长度strlen函数的模拟实现长度不受限制的字符串函数strcpy-复制字符串strcpy函数的模拟实现strcat-追加字符串strcat函数的模拟实现strcmp-比较两个字符串...
  • 字符串函数

    2020-11-28 19:32:50
    字符串获取字符串长度函数字符串拷贝函数字符串追加函数字符串比较函数字符串转换数值字符串切割函数格式化字符串操作函数 获取字符串长度函数 头文件: #include <string.h> 函数定义: size_t strlen(const ...
  • 字符串拷贝函数

    2017-12-01 16:58:10
    字符串拷贝函数,比如要实现:把字符串a复制给字符串b
  • 字符串拷贝函数实现方法:#include &lt;stdio.h&gt; int mystrcmp(const char *src, const char *des){ while(*src == *des) { if (*src == '\0') return 0; src++; des++; } return *src - *des;} ...
  • 函数名: stpcpy功能:拷贝一个字符串到另一个用法:char*stpcpy(char*destin,char*source);程序例:#include#includeintmain(void){charstring[10];char*str1 ="abcdefghi";stpcpy(string, str1);printf("%s\n", string...
  • 说起字符串函数,我想大家都不陌生。字符串函数对二进制数据、字符串和表达式执行不同的运算。下面总结了C语言中的字符串函数。1、函数名: stpcpy功 能: 拷贝一个字符串到另一个用 法:char*stpcpy(char*destin,char*...
  • 长度不受限制的字符串函数 strcpy 字符串拷贝 strcat 字符串追加(拼接) strcmp字符串比较 长度受限制的字符串函数 strncpy 字符串拷贝 strncat 字符串追加(拼接) strncmp 字符串比较 字符串查找 strstr...
  • C实现内存拷贝以及字符串拷贝函数。。。。。。。。。
  • 字符串: 使用单引号或者双引号扩起来的任意字符串,我们都可以称为字符串字符串创建: str1=“hello” str2="world" print(str1) print(str2) 字符串的拼接: 1.使用+进行拼接 str3=str1+str2 注意:不同...
  • /************************************************************************/ /* author:jychen */ /* function 字符串拷贝函数 */ /*Version:0.0.1 */ /****************************************************...
  • 字符、字符串函数

    2019-07-23 21:00:00
    字符串函数 字符串长度函数 strlen(str)(返回值是实际字符串长度不包括‘\0‘) 字符串拷贝函数 strcyp(dest, src) (将src拷贝到dest,'\0' 也一同拷贝) strncpy(s1, s2, n) (复制指定长度字符串) #include&...
  • C 字符串函数

    2018-04-11 11:22:52
    C 字符串函数 C 字符串函数 字符串初始化函数 memset 实现 Example Tip1 Tip2 Tip3 字符串长度函数 strlen 实现 问题 参考 字符串拷贝函数 strcpy 实现 strncpy 实现 memcpy 实现 memmove 实现 ...
  • 文章目录前言一、常用字符串函数1.strlen2.strcpy字符串拷贝3.strcat字符串拼接4.strcmp字符串比较5.strstr查找子串6.strtok字符串切分二、常用内存函数1.memcpy拷贝2.memmove重叠拷贝补充——关于合法性判定 ...
  • 字符串拷贝和内存拷贝函数

    千次阅读 2014-05-09 16:49:58
    字符串拷贝和内存拷贝函数: ...strcpy()函数只能拷贝字符串。strcpy()函数将源字符串 src 的每个字节拷贝到目的字符串 dest 中,src 字符 串末尾的'\0'也被拷贝过去。strcpy()函数返回参数 dest 的起始地址。如果参
  • strcpy函数是用来拷贝字符串函数,str1[]中的字符拷贝到str2[]中。 重写strcpy就是再不调用头文件#include的strcpy函数
  • my_strcpy,my_strncpy,my_strcmp,my_strncmp,...函数的具体实现 */ #include "str.h" #include &lt;assert.h&gt; #include &lt;stdio.h&gt; char * my_strcpy(char *dest, const cha...
  • 一、求字符串长度strlensize_t strlen (const char *str)二、长度不受限制的字符串函数strcpy (字符串拷贝 默认+'\0')char *strcpy(char *dest,char *src)strcmp (字符串比较,根据ascii码)char *strcmp(char *dest,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,678
精华内容 1,871
关键字:

拷贝字符串函数