访问在循环内使用malloc创建的变量比本地声明的变量更快吗？

我有一个循环中的应用程序并使用一个变量 . 基本上它只是将一个字符串复制到变量处理它然后移动到下一个字符串 . 我想知道如何声明我需要使用的变量，所以我编写了这段代码来测试哪一个会更快 . 有趣的是，malloc比我在本地声明的变量更快 . 我也扔了calloc并且它的速度较慢，因为它可能将内存归零 .

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <sys/resource.h>

struct rusage ruse;
#define CPU_TIME (getrusage(RUSAGE_SELF,&ruse), ruse.ru_utime.tv_sec +  ruse.ru_stime.tv_sec + 1e-6 *  (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec))

void gen_random_letters(char *random_buffer, const int len)
{
    int i;
    static const char alphanum[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz";

    /* initialize random seed: */
    srand (time(NULL));

    for ( i = 0; i < len; ++i) {
        random_buffer[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
    }

    random_buffer[len] = 0;
}

int main()
{
    clock_t tic;
    clock_t toc;
    int counter;
    char *buffer_calloc;
    char *buffer_malloc;
    char buffer_local_variable[1450];
    char copy_this[1450];
    double time_spent;
    double first, second;
    int loop_max;

    loop_max = 5000000;
    gen_random_letters(copy_this, sizeof(copy_this));

    /* Try the locally declared variable */
    tic  = clock();
    first = CPU_TIME;
    for ( counter = 0; counter <= loop_max; counter++ )
    {
        //memset(buffer_local_variable,0,sizeof(buffer_local_variable));
        memcpy(buffer_local_variable,copy_this,sizeof(buffer_local_variable));
    }
    toc = clock();
    second = CPU_TIME;
    time_spent = (toc - tic) / CLOCKS_PER_SEC;
    printf("cpu local_variable : %.2f secs\n", second - first);
    printf("Elapsed local_variable: %f seconds\n\n", time_spent);

    /* Try calloc */
    tic  = clock();
    first = CPU_TIME;
    for ( counter = 0; counter <= loop_max; counter++ ){
        buffer_calloc = calloc(1450,sizeof(char*));
        memcpy(buffer_calloc,copy_this,sizeof(buffer_calloc));
        free(buffer_calloc);
    }
    toc = clock();
    second = CPU_TIME;
    time_spent = (toc - tic) / CLOCKS_PER_SEC;
    printf("cpu calloc  : %.2f secs\n", second - first);
    printf("Elapsed calloc : %f seconds\n\n", time_spent);

    /* And now malloc */
    tic  = clock();
    first = CPU_TIME;
    for ( counter = 0; counter <= loop_max; counter++ ){
        buffer_malloc = malloc(1450 * sizeof(char*));
        memcpy(buffer_malloc,copy_this,sizeof(buffer_malloc));
        free(buffer_malloc);
    }
    toc = clock();
    second = CPU_TIME;
    time_spent = (toc - tic) / CLOCKS_PER_SEC;
    printf("Cpu malloc  : %.2f secs\n", second - first);
    printf("Elapsed malloc : %f seconds\n", time_spent);

    return 0;
}

结果：

cpu local_variable : 0.57 secs
Elapsed local_variable : 0.000000 seconds

cpu calloc  : 2.08 secs
Elapsed calloc : 2.000000 seconds

Cpu malloc  : 0.39 secs
Elapsed malloc : 0.000000 seconds

我期望本地声明的变量更快，因为它的内存已经分配，不像malloc需要在每个循环中调用它 . 我的代码是否有缺陷，这就是为什么malloc更快或者就是这样的原因 .