memset与for循环赋初值比较

最新推荐文章于 2024-05-13 15:23:33 发布
最新推荐文章于 2024-05-13 15:23:33 发布
阅读量4.8k 收藏 14
点赞数 5
分类专栏： C/C++ 文章标签： c++ 编译器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hrbust_cxl/article/details/113282187
版权

写代码的时候思考了一会儿memset初始化快还是for循环初始化快。
看了大量的文献资料，结论如下：

  1. 如果对于一个数组进行赋初值操作，memset肯定比for循环快
  2. memset赋初值是按字节为单位的，如果要赋一些比较难的值（33，22等），就比较难
  3. 接上，因为memset是按字节为单位赋初值，当变量所占字节数越大，速度越慢（int的数组比char慢）

测试代码如下：

#include <iostream>
#include <string>
#include <cstring>
#include <chrono>
#include <vector>
#include <algorithm>
#include <numeric>

using namespace std;
using namespace std::chrono;
const int MAXROWNUM = 5e3;
const int MAXCOLNUM = 5e3;
const int loopTimes = 10;
const int loop = 10;

int arr[MAXROWNUM][MAXCOLNUM];
int arr0[MAXROWNUM][MAXCOLNUM];
int arr1[MAXROWNUM][MAXCOLNUM];
int arr2[MAXROWNUM][MAXCOLNUM];
int arr3[MAXROWNUM][MAXCOLNUM];
int arr4[MAXROWNUM][MAXCOLNUM];
int arr5[MAXROWNUM][MAXCOLNUM];
int arr6[MAXROWNUM][MAXCOLNUM];
int arr7[MAXROWNUM][MAXCOLNUM];
int arr8[MAXROWNUM][MAXCOLNUM];
int arr9[MAXROWNUM][MAXCOLNUM];
char str0[MAXROWNUM][MAXCOLNUM];
char str1[MAXROWNUM][MAXCOLNUM];
char str2[MAXROWNUM][MAXCOLNUM];
char str3[MAXROWNUM][MAXCOLNUM];
char str4[MAXROWNUM][MAXCOLNUM];
char str5[MAXROWNUM][MAXCOLNUM];
char str6[MAXROWNUM][MAXCOLNUM];
char str7[MAXROWNUM][MAXCOLNUM];
char str8[MAXROWNUM][MAXCOLNUM];
char str9[MAXROWNUM][MAXCOLNUM];
char str[MAXROWNUM][MAXCOLNUM];
long long memsetfunc_i(){
    auto start = system_clock::now();
    int len =MAXROWNUM*MAXCOLNUM*sizeof(int);

    memset(arr,0, len);
    auto end = system_clock::now();
    auto tt = duration_cast<microseconds>(end - start);
//    printf("memset cost %.3f us\n",tt.count());
    return tt.count();
}

long long memsettenfunc_i(){
    auto start = system_clock::now();
    int len =MAXROWNUM*MAXCOLNUM*sizeof(int);
    for (int i = 0; i < loopTimes; ++i) {
        memset(arr,0, len);
    }
    auto end = system_clock::now();
    auto tt = duration_cast<microseconds>(end - start);
    return tt.count();
}

long long forfunc_i(){
    auto start1 = system_clock::now();
    for (int i = 0; i < MAXROWNUM; ++i) {
        for (int j = 0; j < MAXCOLNUM; ++j) {
            arr[i][j] = 0;
        }
    }

    auto end1 = system_clock::now();
    auto tt1 = duration_cast<microseconds>(end1 - start1);
    return tt1.count();
}

long long fortenfunc_i(){
    auto start1 = system_clock::now();

    for (int k = 0; k < loopTimes; ++k) {
        for (int i = 0; i < MAXROWNUM; ++i) {
            for (int j = 0; j < MAXCOLNUM; ++j) {
                arr[i][j] = 0;
            }
        }
    }
    auto end1 = system_clock::now();
    auto tt1 = duration_cast<microseconds>(end1 - start1);
    return tt1.count();
}


long long memsetfunc_c(){
    auto start = system_clock::now();
    int len =MAXROWNUM*MAXCOLNUM*sizeof(char);

    memset(str,'0', len);
    auto end = system_clock::now();
    auto tt = duration_cast<microseconds>(end - start);
//    printf("memset cost %.3f us\n",tt.count());
    return tt.count();
}

long long memsettenfunc_c(){
    auto start = system_clock::now();
    int len =MAXROWNUM*MAXCOLNUM*sizeof(char);
    for (int i = 0; i < loopTimes; ++i) {
        memset(str,'0', len);
    }
    auto end = system_clock::now();
    auto tt = duration_cast<microseconds>(end - start);
    return tt.count();
}

long long forfunc_c(){
    auto start1 = system_clock::now();
    for (int i = 0; i < MAXROWNUM; ++i) {
        for (int j = 0; j < MAXCOLNUM; ++j) {
            str[i][j] = '0';
        }
    }
    auto end1 = system_clock::now();
    auto tt1 = duration_cast<microseconds>(end1 - start1);
    return tt1.count();
}

long long fortenfunc_c(){
    auto start1 = system_clock::now();
    for (int k = 0; k < loopTimes; ++k) {
        for (int i = 0; i < MAXROWNUM; ++i) {
            for (int j = 0; j < MAXCOLNUM; ++j) {
                str[i][j] = '0';
            }
        }
    }

    auto end1 = system_clock::now();
    auto tt1 = duration_cast<microseconds>(end1 - start1);
    return tt1.count();
}

long long memsettendifffunc_c(){
    auto start = system_clock::now();
    int len =MAXROWNUM*MAXCOLNUM*sizeof(char);
    memset(str0,'0', len);
    memset(str1,'0', len);
    memset(str2,'0', len);
    memset(str3,'0', len);
    memset(str4,'0', len);
    memset(str5,'0', len);
    memset(str6,'0', len);
    memset(str7,'0', len);
    memset(str8,'0', len);
    memset(str9,'0', len);
    auto end = system_clock::now();
    auto tt = duration_cast<microseconds>(end - start);
    return tt.count();
}

long long fortendifffunc_c(){
    auto start1 = system_clock::now();
    for (int i = 0; i < MAXROWNUM; ++i) {
        for (int j = 0; j < MAXCOLNUM; ++j) {
            str0[i][j] = '0';
            str1[i][j] = '0';
            str2[i][j] = '0';
            str3[i][j] = '0';
            str4[i][j] = '0';
            str5[i][j] = '0';
            str6[i][j] = '0';
            str7[i][j] = '0';
            str8[i][j] = '0';
            str9[i][j] = '0';
        }
    }

    auto end1 = system_clock::now();
    auto tt1 = duration_cast<microseconds>(end1 - start1);
    return tt1.count();
}

long long memsettendifffunc(){
    auto start = system_clock::now();
    int len =MAXROWNUM*MAXCOLNUM*sizeof(char);
    memset(arr0,0, len);
    memset(arr1,0, len);
    memset(arr2,0, len);
    memset(arr3,0, len);
    memset(arr4,0, len);
    memset(arr5,0, len);
    memset(arr6,0, len);
    memset(arr7,0, len);
    memset(arr8,0, len);
    memset(arr9,0, len);
    auto end = system_clock::now();
    auto tt = duration_cast<microseconds>(end - start);
    return tt.count();
}

long long fortendifffunc(){
    auto start1 = system_clock::now();
    for (int i = 0; i < MAXROWNUM; ++i) {
        for (int j = 0; j < MAXCOLNUM; ++j) {
            arr0[i][j] = 0;
            arr1[i][j] = 0;
            arr2[i][j] = 0;
            arr3[i][j] = 0;
            arr4[i][j] = 0;
            arr5[i][j] = 0;
            arr6[i][j] = 0;
            arr7[i][j] = 0;
            arr8[i][j] = 0;
            arr9[i][j] = 0;
        }
    }

    auto end1 = system_clock::now();
    auto tt1 = duration_cast<microseconds>(end1 - start1);
    return tt1.count();
}

vector<long long> ans;

double getAns(long long(*p)()){
    ans.clear();
    for (int i = 0; i < loop; ++i) {
        ans.push_back((*p)());
    }
    sort(ans.begin(),ans.end());
    double cost = accumulate(ans.begin()+2, ans.end()-2, 0.0) / static_cast<double>(ans.size()-6);
    cost = cost/1000;
    return cost;
}

int main() {
    double m1,m10,f1,f10,cm1,cm10,cf1,cf10,cmd10,cfd10,md10,fd10;
    m1 = getAns(memsetfunc_i);
    m10 = getAns(memsettenfunc_i);
    f1 = getAns(forfunc_i);
    f10 = getAns(fortenfunc_i);
    cm1 = getAns(memsetfunc_c);
    cm10 = getAns(memsettenfunc_c);
    cf1 = getAns(forfunc_c);
    cf10 = getAns(fortenfunc_c);
    cmd10 = getAns(memsettendifffunc_c);
    cfd10 = getAns(fortendifffunc_c);
    md10 = getAns(memsettendifffunc);
    fd10 = getAns(fortendifffunc);
    printf("int数组memset一次耗时:%.3fms\tint数组for循环一次耗时:%.3fms\n",m1,f1);
    printf("int数组memset十次耗时:%.3fms\tint数组for循环十次耗时:%.3fms\n",m10,f10);
    printf("不同的十个int数组memset耗时:%.3fms\t不同的十个int数组for循环耗时:%.3fms\n",md10,fd10);
    printf("\n");
    printf("char数组memset一次耗时:%.3fms\tchar数组for循环一次耗时:%.3fms\n",cm1,cf1);
    printf("char数组memset十次耗时:%.3fms\tchar数组for循环十次耗时:%.3fms\n",cm10,cf10);
    printf("不同的十个char数组memset耗时:%.3fms\t不同的十个char数组for循环耗时:%.3fms\n",cmd10,cfd10);
}

数组都开在的栈区，因此数组不能设的太大。。。
运行结果如下：可以佐证上诉的结论。
运行结果

memset具体的实现可以看一下下面这个博客，写的很仔细：https://www.cnblogs.com/hoodlum1980/p/3505802.html。

以大佬的总结作为我的总结：

  1. 对数组使用初始化列表，或 memset 两者在底层上可能等效。（msvc编译器将前者处理为后者）。
  2. 对数组用循环初始化，和使用 memset 初始化相比，很有可能等效。即使不等效（memset 调用了 SSE2 扩展），也不可能达到成为一个优化命题和关注点。
  3. 如果一定要说有点区别，那就是如果是对一个整数数组用初始化列表或者循环初始化，那么编译器不需要考虑地址对齐的问题（因为编译器必然把数组分配到对齐的地址），而 memset 则需要考虑传入的地址是否已对齐到某个基本粒度，并对此未对齐部分作处理。
  4. 当对一个随机数据组成的内存块进行清零操作，memset 看起来仿佛是唯一正确的可选方式（如果所在平台无此函数，则可以用手写循环替代）。声明数组时提供初始化列表，声明后再调用 memset 或者使用循环初始化（显然，在能够使用 memset 时，循环写法在高级语言层面不如前者简洁），无论是代码规范还是性能层面，这些写法都不存在值得强调的绝对优劣关系。
zju_cxl
关注
  • 5
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c语言memset字符串赋值,C语言 数组初始化的三种常用方法（{0}, memset, for循环赋值）以及原理...
weixin_39872257的博客
05-18 1175
C语言中，数组初始化的方式主要有三种：1、声明时，使用 {0} 初始化；2、使用memset；3、用for循环赋值。那么，这三种方法的原理以及效率如何呢？ 请看下面的测试代码：#defineARRAY_SIZE_MAX(1*1024*1024)voidfunction1(){chararray[ARRAY_SIZE_MAX]={0};//声明时使用{0}初始化为全0}voidf...
谁来解答下！！memset,for,while,fill()初始化数组的效率对比...
liliflashfly的专栏
12-23 3526
         我的多次结果还是memset最快，但网上有说for()循环初始化数组比memset快的（在int下），因为memset每次只能操作一个字节。不知道大家测出来结果如何或这是我的测试程序原理错了？#include  #include  #include  using namespace std;const int n=10000000;templa
memset初始化值的效率秒杀for循环
weixin_30409849的博客
04-29 448
<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">在一亿数据的赋值下，memset使用了1ms,而for循环使用了136ms</span> 贴上代码： #include <st...
关于 for 和 memset 对数组赋值的时间比较
原原的博客
10-17 115
for memset 数组赋值
同一块内存，连续两次memset，耗时相差4倍！揪出隐藏的性能杀手！
最新发布
IT界那些事儿
05-13 166
本专题除讲解常见性能问题以及分析、调优手段外，还会重点讲解一些对系统性能至关重要，却又经常被忽视的高级话题，如等。此外，还会涉及到等话题。有这么一道题:问：1. 三次memset()的性能有差异吗？2. 为什么？3. 如何调优？该如何回答呢？先简单验证下这三次memset()的性能到底有没有差异。
memset和循环的比较
xl2015190026的博客
07-28 4017
经过测试，对于1e8的数组，memset比循环快一倍左右。 但是如果有n个数组需要清零，memset只能一个一个清零，但是循环可以一次性清零。 当n>2时，循环比memset好。 #include #include #include using namespace std; const int maxn = 1e8; double s,e; int A[maxn]; int B[m
初始化测试，memset，for，fill
小媛在努力~
04-01 2031
<br /><br />fill的表现中规中矩，好处是可以赋各种值。<br /> <br />for不稳定<br /> <br />memset速度领先<br /> <br /> <br /> <br />#include <queue> #include <stack> #include <math.h> #include <stdio.h> #include <stdlib.h> #include <iostream> #include <limits.h> #include <strin
字符串数组初始化0 与memset 0 效率的分析
热门推荐
ace_fei的专栏
04-11 2万+
转自http://hi.baidu.com/yangyangye2008/blog/item/cec4da0e3007c7366159f3c1.html 最近要分析程序的性能，所以上网查了查资料，的处理下面结论： #defineARRAYSIZE 2048 voidmain() {     chararrayA[ARRAYSIZE]={0};     chararrayB[ARRAY
uglmemset和for循环的区别
qingfengtsing的专栏
11-28 849
从现象来说，产生数据异常最有可能的情况有两种。 1. 你程序中的数据访问方式不合法（CPU无法发起给定位宽向给定地址的读/写传输）。 2. 访问地址不合法（地址不存在或者是MMU表中无法寻找到，如果有MMU的话）。 但可能性大的，应该是第一种，通常由由对齐问题引起，在大端模式的CPU下容易出线此错误，而同样的程序在小端模式的CPU比如x86下则不会出线此错误。因为大端模式的CPU有自然对
C语言 数组初始化的三种常用方法（{0}, memset, for循环赋值）以及原理
06-10 1053
C语言 数组初始化的三种常用方法（{0}, memset, for循环赋值）以及原理 C语言中，数组初始化的方式主要有三种： 1、声明时，使用 {0} 初始化； 2、使用memset； 3、用for循环赋值。 那么，这三种方法的原理以及效率如何呢？ 请看下面的测试代码： ...
memset头文件c++版
05-02
memset头文件 c++版
memset函数用法.rar
04-17
`memset`函数通过循环或位操作（取决于编译器的实现）将目标内存区域的每个字节都设置为`c`对应的值。这种操作在执行效率上通常比手动逐个赋值快很多，尤其在处理大块内存时。 ### 3. 使用示例 假设我们有一个包含...
C语言memset函数使用方法详解
12-31
C语言memset函数使用方法详解 一。函数原形 void * memset（void*s, int ch,size_t n） 二。函数作用 将以s内存地址为首的连续n个字节的内容置成ch，一般用来对大量结构体和数组进行清零 三。常见错误 1.搞反...
C++数组初始化方式：for循环或memset
个人工作中学到的专业技术与职业发展知识笔记
05-14 1914
1、默认初始化： int arr[26] = {1}; // 初始化为{1，0，0，。。。，0} 注：初始化列表只初始化指出位置处的元素，其他位置默认初始化为0。 参考资料： C/C++数组初始化 2、for循环初始化： int arr[26] = {1}; for(int i = 0; i<26;i++){ // 全部初始化为-1 arr[i] = -1; } 3、memset初始化： int arr[26] = {-1}; memset(arr, -1, sizeof(arr))
测试：有关于memset重置和for循环重置的问题
Lyra's DDF
11-04 533
memset和for哪个比较快呢？ 打出代码如下：#include <iostream> #include <algorithm> #include <cstring> #include <cstdio> #include <cstdlib> #include <iomanip> #include <cmath> #include <ctime> #include <stack> #include
fill memset, for小测试
Leave Me Alone
07-10 607
/*很无聊写着玩玩，后来发现memset效率会比fill高出这么多，可惜一般只用来赋值0，-1.。。。。。以后可以用fill来偷偷懒了。。。*/ #include #include using namespace std; #define max 100000000+5 int a[max]; int main() {  time_t beg,end;  beg=clock();
memset
baidu_34549562的博客
09-01 995
char a[10]; memset(a,‘0’,sizeof(a); 将a的所有元素编程字符’0’，但是memset对int型直接赋初值会出错。 因为memset是以字节为单位就是对array指向的内存的4个字节进行赋值，4个字节合一起就是 00000001 00000001 00000001 00000001 就等于16843009，就完成了对一个INT元素的赋值了 所以memset对非ch...
memset函数的一个用法
terry1315的博客
08-13 657
char buff[BUFF_LEN]; memset(&amp;buff, 0, sizeof(buff)); 用memset函数给数组赋初值0；避免出现printf时出错。 void *(memset)(void *s, int c, size_t n) { const unsigned char uc = c; unsigned char *su; for ...
memst函数和for循环赋初值
09-22
`memst()` 函数是一个内存设置函数，用于将一段内存空间的值都设置为给定的值。它的语法如下： ```c++ void* memset(void* ptr, int value, size_t num); ``` 其中，`ptr` 是指向要设置的内存空间的指针，`value` 是要设置的值，`num` 是要设置的内存空间的大小。 比如，以下代码将一个长度为 10 的整型数组 `arr` 的所有元素都设置为 0： ```c++ int arr[10]; memset(arr, 0, sizeof(arr)); ``` 而对于 for 循环赋初值，我们通常会使用以下语法： ```c++ for (int i = 0; i < n; i++) { // 对数组、变量等进行赋初值 } ``` 其中，`n` 是循环次数，`i` 是循环变量，我们可以在循环体内对数组、变量等进行赋初值操作。比如，以下代码将一个长度为 10 的整型数组 `arr` 的所有元素都设置为 0： ```c++ int arr[10]; for (int i = 0; i < 10; i++) { arr[i] = 0; } ``` 这样做的效果与使用 `memset()` 函数是相同的。不过在一些情况下，使用 for 循环赋初值可能更加方便和灵活。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值