Question

我想创建随机数据进行测试。我想用100个随机长度的字符串填充数组'A'。

示例：

array[0] = "AAAAA"
array[1] = "AAAAAAAA"
array[2] = "A"
...

char **create_string()
{
    char **array = malloc(sizeof(**array)); 

    srand((unsigned int)time(NULL));
    int random = 0;

    int i, j;
    for(int i=0; i<100; i++)
    {
        random = rand() % 100;
        for(j=0; j < random; j++)
        {
           array[i] = // some sort of string append that would be cheap.
        }
    }
}

我正在查看此C string append，他们使用strcat。有没有更好的方法来解决我的问题？因为我将在循环中运行以创建那些随机大小的字符串。

Answer 1

#include  <stdio.h>
#include <stdlib.h>
#include <time.h>
char **create_string(size_t n) {
    char **array = malloc(sizeof(char*) * n); 
    int i, j;
    for(i=0; i<100; i++)
    {   
        size_t sz = rand() % 100;
        array[i] = malloc(sz + 1); 
        for(j=0; j < sz; j++) {
            array[i][j] = 'A';
        }
        array[i][sz] = 0;
    }   
    return array;
}

int  main() {
    char **array;
    size_t i;
    srand((unsigned int)time(NULL));
    array = create_string(100);
    for (i = 0; i < 100; i++)
        printf("%s\n", array[i]);
    return 0;    

}

或者，您可以创建模板字符串并将所需数量的字符复制到每个随机字符串中：

char **create_string(size_t n) {
    char template[101];
    char **array = malloc(sizeof(char*) * n); 
    int i;

    for (i = 0; i < 100; i++)
        template[i] = 'A';
    template[100] = 0;
    for(i = 0; i < n; i++) {
        size_t sz = rand() % 100;
        array[i] = malloc(sz + 1); 
        strncpy(array[i], template, sz);
        array[i][sz] = 0;
    }   
    return array;
}

Answer 2

这取决于您想要的字符串长度的分布。这是字符串长度的均匀分布，从0到200。

int n = rand() % 200 * sizeof(*array);
array[i] = malloc(n + 1);
memset(array[i], 'A', n);
array[i][n] = '\0';

但你可以有高斯分布，泊松分布等等。

Answer 3

 char **create_string()
  {
  char **array = malloc(sizeof(char *) * 100);

             srand((unisgned int)time(NULL));

        int i;
        for (i = 0; i <100;i++)
        {
            int random = rand() % 100;
            array[i] = malloc(random);
            memset(array[i],'A',random-1);
            array[random-1] = '\0';
        }
        return array;
    }

你要解决的问题：如果随机为0，会发生什么？随机数也不会是等分布的。只有2的幂才能达到模数。

Answer 4

这是一种不对任何单个字符串设置上限的方法，但确实将精确绑定在所有字符串的总长度上。它也只调用malloc两次。

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

#define TOT_SIZE (5000) /* adjust to taste */
#define TOT_STRS (100)

char **create_strings()
{
    char **array = (char**) malloc(TOT_STRS * sizeof(char *));
    char *str    = (char*)  malloc(TOT_SIZE);
    int  zeros   = 1;
    int  i;

    memset(str, 'A', TOT_SIZE - 1);

    str[TOT_SIZE - 1] = 0;

    while (zeros < TOT_STRS)
    {
        int pos = rand() % TOT_SIZE;

        if (str[pos] != 0)
        {
            str[pos] = 0;
            zeros++;
        }
    }

    array[0] = str;

    for (i = 1; i < TOT_STRS; i++)
    {
        array[i] = array[i - 1] + strlen(array[i - 1]) + 1;
    }

    return array;
}

一个简短的测试程序：

int main()
{
    char **a = create_strings();
    int i;

    for (i = 0; i < TOT_STRS; i++)
    {
        printf("%3d: %s\n", i, a[i]);
    }

    return 0;
}

此代码假定所有随机字符串都需要不重叠。如果它们可以在内存中重叠，则只需要一个字符串，以及指向该字符串中不同起点的指针数组。

Answer 5

您不必分配真正的100个字符串。首先，您只需声明一个足够长的数组char long_array[100]。然后你使用random = rand() % 100;随机获取。其次，您只需将long_array和random传递给您的函数即可。然后你的问题就解决了。

Answer 6

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

char **create_string(const size_t array_size,
               const size_t string_size,
               const unsigned char chr)
{

    srand((unsigned)time(NULL));
    char ** array = malloc(array_size * sizeof (char *));

    size_t t;

    for (t = 0; t < array_size; ++t) {
        array[t] = malloc(string_size * sizeof(char));
        array[t][string_size] = '\0';
        memset(array[t], chr, (rand() % string_size) + 1);
    }

    return array;   
}

main() {

    char ** randstring = create_string(10, 7, 'A');
    int t = 0;
    for (; t < 10; ++t)
        printf("%s\n", randstring[t]);
    return 0;
}

可能的输出

AAAAAA
AAAAA
AAAAAA
AAA
AAAAA
AAAAAA
AAAAAA
AAAAAAA
AAAA
AAAA

将一个字符附加到列表n次

6 个答案: