memset()相关使用

  • Post author:
  • Post category:其他




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。

  1. memset() 函数常用于内存空间初始化。如:

    char str[100];

    memset(str,0,100);

  2. 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的内存地址溢出。

  1. strcpy

    用法:extern char *strcpy(char *dest,char *src);

    功能:把src所指由NULL结束的字符串复制到dest所指的数组中。

    说明:src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

    返回指向dest的指针。
  2. memcpy

    用法:extern void *memcpy(void *dest, void *src, unsigned int count);

    功能:由src所指内存区域复制count个字节到dest所指内存区域。

    说明:src和dest所指内存区域不能重叠,函数返回指向dest的指针。
  3. 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种情况



版权声明:本文为xuyin1204原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。