c标准库＜string.h＞

- 日理万妓 2022-12-27 11:10 108阅读 0赞

### 文章目录 ###

*  memchr
 *   *  理论
     *  实践
 *  strspn、strcspn
 *   *  理论
     *  实现
     *  实践
 *  strtok
 *   *  理论
     *  实践
     *  实现
 *  strcpy、strdup、strndup
 *   *  理论
     *  实现
     *  实践
     *   *  strcpy
         *  strdup
         *  memcpy
 *  strlen
 *   *  实现
     *  实践
     *   *  '\\0'、NULL、'\\n'、'\\t'
         *  strlen( ) VS sizeof( )
 *  memset
 *   *  理论
     *  使用

# memchr #

## 理论 ##

/*
    * 功能：在参数 str 所指向的字符串中搜索第一次出现字符 c（一个无符号字符）的位置。
    * 参数：
    * 		str -- 指向要执行搜索的内存块。
    * 		c -- 以 int 形式传递的值，但是函数在每次字节搜索时是使用该值的无符号字符形式。
    * 返回值：
    * 		该函数返回一个指向匹配字节的指针，如果在给定的内存区域未出现字符，则返回 NULL。
    */
    char *strchr(const char *str, int c)
    /*
    * 功能：在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。
    * 参数：
    * 		str -- 指向要执行搜索的内存块。
    * 		c -- 以 int 形式传递的值，但是函数在每次字节搜索时是使用该值的无符号字符形式。
    * 		n -- 要被分析的字节数。
    * 返回值：
    * 		该函数返回一个指向第一个匹配字节的指针，如果在给定的内存区域未出现字符，则返回 NULL。
    */
    void *memchr(const void *str, int c, size_t n)
    /*
    * 功能： 在参数 str 所指向的字符串中搜索最后一次出现字符 c（一个无符号字符）的位置。
    * 参数：  
    *        str -- C 字符串。
    *        c -- 要搜索的字符。以 int 形式传递，但是最终会转换回 char 形式。
    * 返回值：
    *   该函数返回一个指向最后一个匹配字节的指针。如果未找到该值，则函数返回一个空指针。
    */
    
    char *strrchr(const char *str, int c)

## 实践 ##

#include <stdio.h>
    #include <string.h>
    #include <memory.h>
    
    int main ()
    {
        
        const char str[] = "http://www.runoob.com";
        const char ch = '.';
        char *ret;
    
        ret = strchr(str, ch);
    
        printf("strchr |%c| 之后的字符串是 - |%s|\n", ch, ret);
    
        ret = (char*)memchr(str, ch, strlen(str));
    
        printf("memchr |%c| 之后的字符串是 - |%s|\n", ch, ret);
    
        ret = strrchr(str, ch);
    
        printf("strrchr |%c| 之后的字符串是 - |%s|\n", ch, ret);
    
    
    
        return(0);
    }

![在这里插入图片描述][20201218144658269.png]

#include <stdio.h>
    #include <string.h>
    #include <memory.h>
    #include <malloc.h>
    
    /**
     * 从字符串左边开始将包含给定分隔符在内的右边截断
     * @param string {char*} 源字符串
     * @param delimiter {int} 分隔符
     * @return {char*} 分隔符以右的字符串，当为NULL时表明未找到指定分隔符
     */
    char *acl_split_at(char *s, int delimiter){
        
        char   *cp;
    
        if ((cp = strchr(s, delimiter)) != 0){
        
            *cp++ = 0;
        }
    
        return cp;
    }
    
    /**
     * 从字符串右边开始将包含给定分隔符在内的右边截断
     * @param string {char*} 源字符串
     * @param delimiter {int} 分隔符
     * @return {char*} 分隔符以右的字符串，当为NULL时表明未找到指定分隔符
     */
    char *acl_split_at_right(char *s, int delimiter){
        
        char   *cp;
    
        if ((cp = strrchr(s, delimiter)) != 0)
            *cp++ = 0;
        return cp;
    }
    
    
    
    int main ()
    {
        
        //char *str = "127.0.0.1:9162";  // error: because it's const
        char *str = strdup("127.0.0.1:9162");
        printf("%s ---- %s\n", str, acl_split_at(str, '.'));
        free(str);
    
        str = strdup("127.0.0.1:9162");
        printf("%s ---- %s", str, acl_split_at_right(str, '.'));
        free(str);
        return(0);
    }

![在这里插入图片描述][2020121815114240.png]

# strspn、strcspn #

## 理论 ##

/*
    * 功能: 找到str1 中第一个不在字符串 str2 中出现的字符下标。
    * 参数：
    * 		* str1：要被检索的C字符串
    * 		* str2：该字符串包含了要在str1中进行匹配的字符列表
    * 返回值：
    *    该函数返回 str1 中第一个不在字符串 str2 中出现的字符下标。
    */
    size_t strspn(const char *str1, const char *str2)
    
    /*
    * 功能： 检索字符串 str1第一个匹配能够在str2中匹配到的下标
    * 参数：
    * 		* str1：要被检索的C字符串
    * 		* str2：该字符串包含了要在str1中进行匹配的字符列表
    * 返回值：
    *    该函数返回 str1 开头连续都不含字符串 str2 中字符的字符数。
    */
    
    size_t strcspn(const char *str1, const char *str2)

## 实现 ##

int my_strspn(const char *s,const char *accept){
        
    
        const char *p;
    
        const char *a;
    
        int count = 0;
    
        for(p = s; *p != '\0'; ++p){
        
            for (a = accept; *a != '\0'; ++a){
        
                if (*p == *a){
        
                    ++count;
                    break;
                }
            }
            
            if (*a == '\0'){
        
                return count;
            }
        }
    
        return count;
    }
    
    int my_strcspn(const char *s,const char *accept)
    {
        
        const char *p;
        const char *a;
        int count = 0;
        for(p = s; *p != '\0'; ++p)
        {
        
            for (a = accept; *a != '\0'; ++a)
            {
        
                if (*p == *a)
                {
        
                    return count;
                }
    
            }   //里面的for循环到此为止
            if (*a == '\0')
            {
        
                ++ count;
            }
    
        }   //外面的for循环到此为止
    
        return count;
    }

## 实践 ##

#include <stdio.h>
    #include <string.h>
    
    int main () {
        
        int len;
        const char str1[] = "25,142,330,Smith,J,239-4123";
        const char str2[] = ",0123456789";
    
        len = strspn(str1, str2);
    
        printf("Length of initial segment matching %d\n", len );
    
        return(0);
    }

![在这里插入图片描述][20201217130451724.png]

#include <stdio.h>
    #include <string.h>
    
    int main () {
        
       int len;
       const char str1[] = "25,142,330,Smith,J,239-4123";
       const char str2[] = "0123456789";
    
       len = strspn(str1, str2);
    
       printf("Length of initial segment matching %d\n", len );
       
       return(0);
    }

![在这里插入图片描述][20201217131049469.png]

#include <stdio.h>
    #include <string.h>
    
    int main () {
        
       int len;
       const char str1[] = ",,,Smith,J,239-4123";
       const char str2[] = "0123456789";
    
       len = strcspn(str1, str2);
    
       printf("Length of initial segment matching %d\n", len );
       
       return(0);
    }

![在这里插入图片描述][20201217131558975.png]

# strtok #

## 理论 ##

/*
    * 功能： 分解str为一组字符串，delim为分隔符
    * 参数：
    *     * str -- 要被分解成一组小字符串的字符串。
    *     * delim -- 包含分隔符的 C 字符串
    * 返回值：返回被分解的第一个子字符串，如果没有可检索的字符串，则返回一个空指针。
    */
    char *strtok(char *str, const char *delim)

## 实践 ##

#include <string.h>
    #include <stdio.h>
     
    int main () {
        
       char str[80] = "This is - www.runoob.com - website";
       const char s[2] = "-";
       char *token;
       
       /* 获取第一个子字符串 */
       token = strtok(str, s);
       
       /* 继续获取其他的子字符串 */
       while( token != NULL ) {
        
          printf( "%s\n", token );
        
          token = strtok(NULL, s);
       }
       printf("\n%s\n",str);  // 特别要注意分割处理后原字符串 str 会变，变成第一个子字符串
       return(0);
    }

![在这里插入图片描述][20201217132855146.png]

#include <string.h>
    #include <stdio.h>
    
    int main () {
        
        char str[80] = "This www ----- www.runoob.com  website";
        const char *s= "www";
        char *token;
    
        /* 获取第一个子字符串 */
        token = strtok(str, s);
    
        /* 继续获取其他的子字符串 */
        while( token != NULL ) {
        
            printf( "%s\n", token );
    
            token = strtok(NULL, s);
        }
    
        return(0);
    }

![在这里插入图片描述][2020121713261421.png]

## 实现 ##

/**
     * 将给定字符串用另一个分隔符字符串进行分割
     * @param src {char**} 需要被分割的字符串的地址的指针，必须是非空指针，
     *  可以是空字符串，此时该函数返回 NULL
     * @param sep {const char*} 分隔符，非空字符串
     * @return {char*} 当前被分割的字符串的指针位置，src 指向下一个将要进行
     *  分隔的起始位置；
     *  1）当返回 NULL 时，则表示分隔过程结束，此时 src 的指针位置被赋予 '\0'；
     *  2）当返回非 NULL 时，则此时 src 指向的字符串可能是或不是空字符串，
     *     如果指向空字符串，则再次分隔时函数肯定能返回 NULL，否则，当再次分隔时
     *     函数返回非 NULL 指针
     *  举例: 源字符串："abcd=|efg=|hijk", 分隔符 "=|"，则第一次分隔后
     *  src 将指向 "efg"，而返回的地址为 "abcd"
     */
    char *acl_strtok(char **src, const char *sep)
    {
        
        char   *start = *src;
        char   *end;
    
        /*
         * Skip over leading delimiters.
         */
        start += strspn(start, sep);
        if (*start == 0) {
        
            *src = start;
            return 0;
        }
    
        /*
         * Separate off one token.
         */
        end = start + strcspn(start, sep);
        if (*end != 0){
        
            char *bp = end;
            end++;
            bp = NULL;
        }
    
        *src = end;
        return start;
    }
    
    int main () {
        
    
        char *src = ("hello \t\t\tworld! you're welcome to China!");
        char *ptr, *src_saved;
        src_saved = src;  // 这一步：是让src和ptr指向同一个地址
        while ((ptr = acl_mystrtok(&src, " \t,'!")) != 0){
        
            printf("--------------------------------------\r\n");
            printf("ptr: |%s|\r\n", ptr);  //ptr指向src不能够在del中找到的第一个字符的地址
            printf("src: |%s|\r\n", src);  //现在src指向所使用分隔符(一个字符)的下一个字符的地址
            printf("src_saved: |%s|\r\n", src_saved);
        }
    
        return(0);
    }

# strcpy、strdup、strndup #

## 理论 ##

#include <string.h>
    
    /*
    * 功能：把 src 所指向的字符串复制到 dest。
    * 参数： dest -- 指向用于存储复制内容的目标数组。
    * 		src -- 要复制的字符串。
    * 返回值： 该函数返回一个指向最终的目标字符串 dest 的指针。
    * 注意：是如果目标数组 dest 不够大，而源字符串的长度又太长，可能会造成缓冲溢出的情况
    */
    char *strcpy(char *dest, const char *src)
    /*
    * 功能： memcpy()用来拷贝src所指的内存前count个字节到dest所指内存地址上。  memcpy会赋值完整的count个字节，不会因为遇到字符串结束'\0'而结束。
    */
    void *memcpy( void *dest, const void *src, size_t count );
    /*
    * 功能：　strdup（）函数是c语言中常用的一种字符串拷贝库函数，一般和free（）函数成对出现。
    * 注意： strdup()在内部调用了malloc()为变量分配内存，不需要使用返回的字符串时，需要用free()释放相应的内存空间，否则会造成内存泄漏。该函数的返回值是返回一个指针,指向为复制字符串分配的空间;如果分配空间失败,则返回NULL值。
    */
    char *strdup(const char *s); 
    
    char *strndup(const char *s, size_t n);

## 实现 ##

char * strcpy(char * dest, const char * src) // 实现src到dest的复制
    {
        
    　　if ((src == NULL) || (dest == NULL)) //判断参数src和dest的有效性
    　　{
        
    　　　　　　return NULL;
    　　}
    　　char *strdest = dest;        //保存目标字符串的首地址
    　　while ((*strDest++ = *strSrc++)!='\0'); //把src字符串的内容复制到dest下
    　　return strdest;
    }

char * __strdup(const char *s)
    {
        
       size_t  len = strlen(s) +1;
       void *new = malloc(len);
       if (new == NULL)
          return NULL;
       return (char *)memecpy(new,s,len);
    }

// 实现工业级的内存拷贝函数
    void* memcpy(void* dst, const void* src, int count)
    {
        
        assert((dst != NULL)&&(src != NULL));//判断是否为空指针
        void* ret = dst;
        assert(!(src<=dst && dst<(char*)src+count));//判断是否有内存重叠
        assert(!(dst<=src && src<(char*)dst+count));
        while(count--)
        {
        
            *(char*)dst = *(char*)src;
            dst=(char*)dst+1;
            src=(char*)src+1;
        }
        return ret;
    }

void *mymemcpy(void *memTo, const void *memFrom, size_t size)
    {
        
        if((memTo == NULL) || (memFrom == NULL)) //memTo和memFrom必须有效
            return NULL;
        char *tempFrom = (char *)memFrom;             //保存memFrom首地址
        char *tempTo = (char *)memTo;                  //保存memTo首地址
        while(size -- > 0)                //循环size次，复制memFrom的值到memTo中
        *tempTo++ = *tempFrom++ ;
        return memTo;
    }
    
    
    
    
    void *mymemmove(void *dest, const void *src, size_t n)
    {
        
        char temp[n];
        int i;
        char *d = dest;
        const char *s = src;
    
        for (i = 0; i < n; i++)
            temp[i] = s[i];
        for (i = 0; i < n; i++)
            d[i] = temp[i];
    
        return dest;
    }
    
    
    //解决内存重叠的问题，就需要加上逆序拷贝，适用于任何类型
        void* MyMemmove(void* dest, const void* src, size_t num)
        {
        
            char* dest_tmp = (char*)dest;
            const char* src_tmp = (const char*)src;
            assert(dest && src);
            if (src_tmp > dest_tmp || src_tmp + num <= dest_tmp) //情况1和情况2
            {
        
                while(num--) //正序复制
                {
        
                    *dest_tmp++ = *src_tmp++;
                }
            }
            else    //情况3，逆序赋值
            {
        
                //逆序打印，需要把指针调整位置
                dest_tmp += num-1;
                src_tmp += num-1;
                while (num--) {
        
                    *(dest_tmp--) = *(src_tmp--);
                }    
            }
            return dest;
        }

strcpy和memcpy主要有以下3方面的区别。

1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。**strcpy主要实现字符串变量间的拷贝，memcpy主要是内存块间的拷贝**

2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。  
3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy

memmove在copy两个有重叠区域的内存时可以保证copy的正确，而memcopy就不行了。  
①当前src内存区域和dest内存区域完全不重叠  
![在这里插入图片描述][20201224150233200.png]  
②当src内存区域和dest内存区域重叠时且dest所在区域在src所在区域前（这种的因为memcpy可以的原理：是你已经把你需要复制的都复制过了，所以被覆盖不影响）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]  
③当src内存区域和dest内存区域重叠时且src所在区域在dest所在区域前（memcpy在这种情况下，会有一部分数据来不及复制，就被覆盖了）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

#include <stdio.h>
    #include <memory.h>
    
    void test_memcpy(){
        
        char s[] = "1234567890";
        char* sre = s;
        char* p2 = s+2;
        memcpy(p2, sre, 5);
        printf("memcpy  --- > %s\n", p2);  // 12345890
    }
    void test_memmove(){
        
        char s[] = "1234567890";
        char* sre = s;
        char* d = s+2;
        memmove(d, sre, 5);
        printf("memmove --- > %s\n", d);  // 12345890
    }
    int main()
    {
        
        test_memcpy();
        test_memmove();
        return 0;
    }

![在这里插入图片描述][20201224150758681.png]

但memcopy比memmove的速度要快一些

## 实践 ##

### strcpy ###

#include <stdio.h>
    #include <string.h>
     
    int main()
    {
        
       char src[40];
       char dest[100];
      
       memset(dest, '\0', sizeof(dest));
       strcpy(src, "This is runoob.com");   //  This is runoob.com
       strcpy(dest, src);
     
       printf("最终的目标字符串： %s\n", dest);
       
       return(0);
    }

### strdup ###

#include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    
    
    int main(int argc, char** argv){
        
        char *src = "thais is tyhaacdw";
        char *dst;
    
        dst = strdup(src);
        printf("the dest %s\n",dst);
        free(dst);
        return 0;
    }

### memcpy ###

1、将一个字符串数据复制到一块内存。

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #define N 10
    int main(void)
    {
        
        char* target=(char*)malloc(sizeof(char)*N);
        memcpy(target,"0123456789",sizeof(char)*N);
        puts(target);
        free(target);
        return 0;
    }

![在这里插入图片描述][20201216141104239.png]  
2.将一个字符串数据复制到一块内存的指定位置。

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #define N 10
    int main(void)
    {
        
        char* target=(char*)malloc(sizeof(char));
        for(int i=0;i<N;i++){
        
            memcpy(target+i,"a",sizeof(char));
        }
        puts(target);
        free(target);
        return 0;
    }

![在这里插入图片描述][20201216141141349.png]  
3、数据覆盖： 执行memcpy之后，将覆盖原有数据（最多覆盖n个）。

![在这里插入图片描述][20201216141249281.png]  
4、将s中第13个字符开始的4个连续字符复制到d中。(从0开始)

#include<string.h>
    int main(
    {
        
        char* s="GoldenGlobalView";
        char d[20];
        memcpy(d,s+12,4);//从第13个字符(V)开始复制，连续复制4个字符(View)
        d[4]='\0';//memcpy(d,s+14*sizeof(char),4*sizeof(char));也可
        printf("%s",d);
       getchar();
       return 0;
    }

5、在使用时注意不可用字符串，如果是字符串会导致段错误，可以使用asprintf函数复制字符串。

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main()
    {
        
        char *token;
        memcpy(token, "%s1$", 4);
    	return 0;
    }

int main()
    {
        
        char *token;
        asprintf(&token,"%s","%s1$");   // 遇上\0停止
        printf("%s", token);
        return 0;
    }

# strlen #

## 实现 ##

int strlen(const char *str)  /* 使用了一个int型变量 */
    {
        
         if(str==NULL) return 0;
         int len = 0;
         for(; *str++ != '\0'; )
         {
        
             len++;
         }
        return len;
    }

## 实践 ##

### ‘\\0’、NULL、’\\n’、’\\t’ ###

*  ‘\\0’ 表示空字符NULL，对应的ASCII码为dao0，通常用zhuan来表示字符串的结束标志； ASCII0
 *  ‘\\n’ 表示换行，对应的ASCII码为10，通常用在printf函数中，输出换行； ASCII10
 *  '\\t’表示回车符。 ASCII13
 *  ‘0’ 表示字符0， ASCII 48

\\0和\\n在C语言中都是转义字符。

> C语言中，所有的ASCII码都可以用“\\”加数字（一般是8进制数字）来表示。而C中定义了一些字母前加""来表示常见的那些不能显示的ASCII字符，如\\0,\\t,\\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了

1、\\0不是\\n也不是\\t

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    int main(void)
    {
        
        char* s = strdup("aaa\r\n\r\nbbb\r\n\nccc");
        int nleft = strlen(s);
        printf("%s, %d", s, nleft);
        return 0;
    }

![在这里插入图片描述][20201216142742102.png]  
2、 NULL = ‘\\0’ = 0

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    int main(void)
    {
        
        printf(" '\\n'  = %d\n", '\n');
        printf(" '0'   = %d\n", '0');
        printf(" '\\t'  = %d\n", '\t');
        printf(" NULL  = %d\n", (int)NULL);  //  NULL = '\0' = 0
        printf(" '\\0'  = %d\n", '\0');
        printf(" 0     = %d\n", 0);
        return 0;
    }

![在这里插入图片描述][20201216143317675.png]

1.  const char\* 字符串 以 “\\0”结尾。
2.  char\[\] 字符串 以 “\\0”结尾。
3.  string 字符串 不以 “\\0”结尾。
4.  char\[n\] = “string”, 当string 长度+“\\0”>n时，会因空间不足出错。
5.  string.c\_str() 转 const char\* 时， 会在字符串末尾 自动补“\\0”
6.  char\* 转string 时， 会自动把末尾的 “\\0” 去掉。
7.  strlen()是取字符串除去结尾符 “\\0” 的长度。

–  
**在Unix系统下执行 换行操作 用“\\n” 在windows 操作做系统下执行 换行操作 用“\\r\\n” 在Mac操作系统下执行 换行操作用“\\r”**

### strlen( ) VS sizeof( ) ###

1、strlen( )求得的是字符串的长度

例如字符串 str\[20\]= \{“abcd”\};

strlen(str),结果为4

2、sizeof( )计算字符串占的总内存空间

例如字符串 str\[20\]= “abcd”

sizeof(str),结果为20

char *str1 = "asdfgh";
    char str2[] = "asdfgh";
    char str3[8] = {
        'a', 's', 'd'};
    char str4[] = "as\0df";

执行结果是：

sizeof(str1) = 4;  strlen(str1) = 6;
    sizeof(str2) = 7;  strlen(str2) = 6;
    sizeof(str3) = 8;  strlen(str3) = 3;
    sizeof(str4) = 6;  strlen(str4) = 2;

str1是字符指针变量，sizeof 获得的是该指针所占的地址空间，32 位操作系统对应 4 字节，所以结果是 4；strlen 返回的是该字符串的长度，遇到 \\0 结束， \\0 本身不计算在内，故结果是 6。

str2 是字符数组，大小由字符串常量 “asdfgh” 确定，sizeof 获得该数组所占内存空间大小，包括字符串结尾的 \\0 ，所以结果为 7；strlen 同理返回 6。  
str3 也是字符数组，但大小确定为 8，故 sizeof 得到的结果是 8；strlen 统计 \\0 之前所有字符的个数，即为 3；

str4 是常量字符数组，sizeof 得到字符总数即 6；strlen 计算至 \\0 结束，因此返回 2；

总结一句就是 sizeof 计算的是变量的大小，而 strlen 计算的是字符串的长度，前者不受字符 \\0 影响，后者以 \\0 作为长度判定依据。

# memset #

## 理论 ##

/*
    * 功能：将s中当前位置后面的n个字节用c替换
    *  memset 是对较大的数组或结构体进行清零初始化的最快方法，因为它是直接对内存进行操作的。
    * 参数：
    *   str -- 指向要填充的内存块。
    *   c -- 要被设置的值。该值以 int 形式传递，但是函数在填充内存块时是使用该值的无符号字符形式。
    *   n -- 要被设置为该值的字符数
    * 返回值：
    *   该值返回一个指向存储区 str 的指针。
    */
    void *memset(void *str, int c, size_t n)

## 使用 ##

# include <stdio.h>
    # include <string.h>
    int main(void)
    {
        
        int i;  //循环变量
        char str[10];
        char *p = str;
        memset(str, 0, sizeof(str));  //只能写sizeof(str), 不能写sizeof(p)
        for (i=0; i<10; ++i)
        {
        
            printf("%d\x20", str[i]);
        }
        printf("\n");
        return 0;
    }

根据memset函数的不同，输出结果也不同，分为以下几种情况：  
memset(p, 0, sizeof§); //地址的大小都是4字节  
0 0 0 0 -52 -52 -52 -52 -52 -52

memset(p, 0, sizeof(\*p)); //\*p表示的是一个字符变量, 只有一字节  
0 -52 -52 -52 -52 -52 -52 -52 -52 -52

memset(p, 0, sizeof(str));  
0 0 0 0 0 0 0 0 0 0

memset(str, 0, sizeof(str));  
0 0 0 0 0 0 0 0 0 0

[http://c.biancheng.net/view/231.html][http_c.biancheng.net_view_231.html]

#include <stdio.h>
    #include <string.h>
     
    int main ()
    {
        
       char str[50];
     
       strcpy(str,"This is string.h library function");
       puts(str);  
     
       memset(str,'$',7);
       puts(str);   
       
       return(0);
    }

![在这里插入图片描述][20201210160807664.png]

#include <string.h>
    #include <stdio.h>
    #include <memory.h>
    
    int main(void)
    {
        
        char buffer[]="Helloworld\n";
        printf("Buffer before memset:%s\n",buffer);
        memset(buffer + 3,'*',strlen(buffer));
        printf("Buffer after memset:%s\n",buffer);
        return 0;
    }

![在这里插入图片描述][20201215103530418.png]

#include <string.h>
    #include <stdio.h>
    #include <memory.h>
    
    int main(void)
    {
        
        char buffer[]="Helloworld\n";
        printf("Buffer before memset:%s\n",buffer);
        memset(buffer,'*',strlen(buffer) - 3);
        printf("Buffer after memset:%s\n",buffer);
        return 0;
    }

![在这里插入图片描述][2020121510355818.png]

[20201218144658269.png]: /images/20221120/af66facf868444839a830fd42d19c9a3.png
[2020121815114240.png]: https://img-blog.csdnimg.cn/2020121815114240.png
[20201217130451724.png]: https://img-blog.csdnimg.cn/20201217130451724.png
[20201217131049469.png]: https://img-blog.csdnimg.cn/20201217131049469.png
[20201217131558975.png]: https://img-blog.csdnimg.cn/20201217131558975.png
[20201217132855146.png]: https://img-blog.csdnimg.cn/20201217132855146.png
[2020121713261421.png]: https://img-blog.csdnimg.cn/2020121713261421.png
[20201224150233200.png]: https://img-blog.csdnimg.cn/20201224150233200.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20201224150245494.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201224150306654.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[20201224150758681.png]: https://img-blog.csdnimg.cn/20201224150758681.png
[20201216141104239.png]: https://img-blog.csdnimg.cn/20201216141104239.png
[20201216141141349.png]: https://img-blog.csdnimg.cn/20201216141141349.png
[20201216141249281.png]: https://img-blog.csdnimg.cn/20201216141249281.png
[20201216142742102.png]: https://img-blog.csdnimg.cn/20201216142742102.png
[20201216143317675.png]: https://img-blog.csdnimg.cn/20201216143317675.png
[http_c.biancheng.net_view_231.html]: http://c.biancheng.net/view/231.html
[20201210160807664.png]: https://img-blog.csdnimg.cn/20201210160807664.png
[20201215103530418.png]: https://img-blog.csdnimg.cn/20201215103530418.png
[2020121510355818.png]: https://img-blog.csdnimg.cn/2020121510355818.png