1、memset函数及其用法

每种类型的变量都有各自的初始化方法，memset() 函数可以说是初始化内存的“万能函数”，通常为新申请的内存进行初始化工作。 它是直接操作内存空间，mem即“内存”（memory）的意思。该函数的原型为：

# include <string.h>
void *memset(void *s, int c, unsigned long n);

函数的功能是： 将指针变量 s 所指向的前 n 字节的内存单元用一个“整数” c 替换，注意 c 是 int 型。s 是 void* 型的指针变量，所以它可以为任何类型的数据进行初始化。
memset() 的作用是在一段内存块中填充某个给定的值。因为它只能填充一个值，所以该函数的初始化为原始初始化，无法将变量初始化为程序中需要的数据。用memset初始化完后，后面程序中再向该内存空间中存放需要的数据。

memset 一般使用“0”初始化内存单元，而且通常是给数组或结构体进行初始化。一般的变量如 char、int、float、double 等类型的变量直接初始化即可，没有必要用 memset。如果用 memset 的话反而显得麻烦。

当然，数组也可以直接进行初始化，但 memset 是对较大的数组或结构体进行清零初始化的最快方法，因为它是直接对内存进行操作的。

这时有人会问：“字符串数组不是最好用’\0’进行初始化吗？那么可以用 memset 给字符串数组进行初始化吗？也就是说参数 c 可以赋值为’\0’吗？”

可以的。虽然参数 c 要求是一个整数，但是整型和字符型是互通的。但是赋值为 ‘\0’ 和 0 是等价的，因为字符 ‘\0’ 在内存中就是 0。所以在 memset 中初始化为 0 也具有结束标志符 ‘\0’ 的作用，所以通常我们就写“0”。

memset 函数的第三个参数 n 的值一般用 sizeof() 获取，这样比较专业。注意，如果是对指针变量所指向的内存单元进行清零初始化，那么一定要先对这个指针变量进行初始化，即一定要先让它指向某个有效的地址。而且用memset给指针变量如p所指向的内存单元进行初始化时，n 千万别写成 sizeof§，这是新手经常会犯的错误。因为 p 是指针变量，不管 p 指向什么类型的变量，sizeof§ 的值都是 4。

如下面写的测试程序：

# 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

memset(p, 0, 10); //直接写10也行, 但不专业
0 0 0 0 0 0 0 0 0 0

2、memset 函数初始化用法

1. void *memset(void *s,int c,size_t n)

总的作用：将已开辟内存空间 s 的首 n 个字节的值设为值 c。

2. memset() 函数常用于内存空间初始化。如：
   char str[100];
   memset(str,0,100);

3. memset()的深刻内涵：用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为‘ ’或‘/0’；例:char a[100];memset(a, ‘/0’, sizeof(a));

memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度； 例：char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a)，会造成b的内存地址溢出。

strcpy就只能拷贝字符串了，它遇到’/0’就结束拷贝；例：char a[100],b[50];strcpy(a,b);如用strcpy(b,a)，要注意a中的字符串长度（第一个‘/0’之前）是否超过50位，如超过，则会造成b的内存地址溢出。

4. strcpy
   用法：extern char *strcpy(char *dest,char *src);
   功能：把src所指由NULL结束的字符串复制到dest所指的数组中。
   说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
   返回指向dest的指针。
5. memcpy
   用法：extern void *memcpy(void *dest, void *src, unsigned int count);
   功能：由src所指内存区域复制count个字节到dest所指内存区域。
   说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。
6. memset
   用法：extern void *memset(void *buffer, int c, int count);
   功能：把buffer所指内存区域的前count个字节设置成字符c。
   说明：返回指向buffer的指针。

3、memset函数源码实现

void * memset(void *dst, int val, size_t count)
将dst所指向的某一块内存中的前count个 字节的内容全部设置为val指定的ASCII值， 第一个值为指定的内存地址，块的大小由第三个参数指定，这个函数通常为新申请的内存做初始化工作， 其返回值为指向s的指针。
简单来说就是把dst所指内存区域的前count个字节设置为val。返回指向dst的指针。

void * my_memset(void *dst, int val, size_t count)
{
    //把val传给*dst时两个变量类型要相同，需要用到强制类型转换        
	assert(dst);                    //这里需要检验dst的有效性
	char* ret = (char*)dst;         
	while (count--)                
	{
		*ret++ = (char)val;
	}
	return dst;
}

4、memset()初始化做题常用的3种情况

1）对于数组初始化为0操作，常用：

memset(a, 0, sizeof a);

替代循环： for(i=0;i<m;i++) a[i]=0; 缩短运行时间。

2）将数组初始化为无穷大的情况，例如Floyd算法。

通常对于 32位int有符号数，我们将 无穷大INF 设为 0x3f3f3f3f ，

#define INF 0x3f3f3f3f

为什么不设 INF 为最大值 0x7fffffff （32位int有符号数）呢？

原因是对于部分问题可能出现 无穷大 加 无穷大 的情况，这样就会出现溢出错误。

所以至多应选择 0x7fffffff 的一半 0x3fffffff，

而 0x3fffffff 和 0x3f3f3f3f 在数量级上是差不多，

都足够大，但将INF设为 0x3f3f3f3f 就可以用 memset 来初始化。

memset(a,0x3f,sizeof a);

memset 是按字节进行赋值，能将数组整个初始化为 3f3f3f3f3f3f3f3f3f3f3f3f3f… ，也就是无穷大了

这样像用Floyd解决的问题，就不必先跑一边O(n^2)去初始化数组。

3）类似的，需将数组初始化为-1时，可以用：

memset(a,0xff,sizeof a);

这种情况也很常见。

初学时，很多猿不理解为什么memset只对初始化 0 和 -1 时有效。

memset(a,0,sizeof a);

memset(a,-1,sizeof a);

因为 memset 是按字节赋值，即使给它int类型数，它也是只取该数最低位的一个字节来赋值。

所以 memset 传int型参数来初始化只适用于各个字节都相同的数，这样才能表现出期望的效果，

就像 0x3f3f3f3f 0xffffffff 0x00000000 这种。

以上初始化操作对于 64位 long long 有符号数 同样适用。

#define ll_INF 0x3f3f3f3f3f3f3f3f

5、memset()函数的使用注意

C语言中memset源码如下：

void *memset(void *s, int c, size_t count)
{
    char *xs = s;

    while (count--)
        *xs++ = c;
    return s;
}

我们可以发现，在memset()函数中，会将（void *）类型转换成（char *）类型，这样会有什么影响呢
1、试验一

#include <stdio.h>
#include <string.h>
 
int main(void)
{
     int i=0,j=0;
     int array_1[16];
     char array_2[16];
 
     memset(array_1, 0, 16);
     memset(array_2, 0, 16);
 
     printf("[array_1]:");
     for(i; i<16; i++)
     {
         printf("%d  ",array_1[i]);
     }
     printf("\n");
 
     printf("[array_2]:");
     for(j; j<16; j++)
     {
         printf("%d  ",array_2[j]);
     }
     printf("\n");
 
     return 0;
}

这里分别设置两个类型的数组，一个int型，一个char型，那么输出结果如下：

[array_1]:0 0 0 0 1835627636 1600061541 1869833334 1952802655 1 0 4196205 0 0 0 0 0
[array_2]:0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

可以发现，这时候int型的数组初始化是异常的。若细心一点可以发现，int型数组的前4个成员都是为0的（16个字节），这个长度刚好是array_2的长度。那这是不是由于memset是以char为单位进行置0，所以只初始化了int型数组的前四个成员呢？

2、试验二：

memset(array_1, 0, 64);

那么输出结果如下：

[array_1]:0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
[array_2]:0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

可以发现，int型数组初始化完成了。那么是不是指针转换是数据丢失呢？

3、实验三：

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

int main(void)
{
    int *addr_1 = (int *)0x12345678;

    char *addr_2 = (void *)addr_1;

    printf("addr_1 : %p\n",addr_1);
    printf("addr_2 : %p\n",addr_2);

    return 0;
}

那么输出结果如下：

addr_1 : 0x12345678
addr_2 : 0x12345678

也是就说，不同类型的指针的指针长度是一样的，但是，指针偏移的时候会根据所声明的类型来进行偏移。如同样是prt++，int *表示偏移是4个字节，char *则表示偏移是1个字节

既然这样的话，那么如果结构体里面成员类型不同的话，那么结构体的初始化也会有影响吗？

4、实验四：

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

typedef struct _s_param
{
　　int a;
　　int b;
　　char c;
}S_PARAM;

typedef struct _s_var
{
　　char a;
　　char b;
　　int c;
}S_VAR;

int main(void)
{
　　S_PARAM param;
　　S_VAR var;

　　memset(&param, 0, sizeof(S_PARAM));
　　memset(&var, 0, sizeof(S_VAR));

　　printf("[param(%ld)] a=%d, b=%d, c=%d\n",sizeof(S_PARAM), param.a,param.b,param.c);
　　printf("[var(%ld)] a=%d, b=%d, c=%d\n",sizeof(S_VAR), var.a,var.b,var.c);
}

那么输出结果如下：

[param(12)] a=0, b=0, c=0
[var(8)] a=0, b=0, c=0

可以发现结构体的初始化是正常的，这是因为输入的长度是结构体的长度，那这样的话，那前面的数组初始化用sizeof的话，应该也是初始化正常的。

参考文献：
memset函数及其用法，C语言memset函数详解
memset()函数的使用注意
memset 函数初始化用法
memset函数使用详解
memset()初始化做题常用的3种情况