c - 在双指针中存储字符串时出现问题

Question

我一直在这样做code wars challenge其中你必须取一个字符串，并将每个字母大写，形成一个墨西哥波浪形的字符串数组。例如，像这样的输入字符串

你好

将导致 ["Hello", "hEllo", "heLlo", "helLo", "hellO"]

我设法用 JavaScript 完成了它，并决定在 C 中尝试它。实际代码本身正在工作，因为它打印了正确的输出，但我遇到的问题实际上是存储双指针内的字符串。

这是我的代码:

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

void wave(char *s, char **array);

int main(void)
{
    char *s = malloc(6);
    strcpy(s, "hello");

    char **array = malloc(pow(strlen(s)+1, 2));

    wave(s, array);

    for (int i = 0; i < strlen(s); i++)
    {
        printf("s = %s\n", array[i]);
    }

    free(array);
    free(s);

    return 0;
}

void wave(char *s, char **array)
{
    char s2[strlen(s)+1];

    for (int i = 0; i < strlen(s); i++)
    {
        s[i] = tolower(s[i]);
    }

    int array_index = 0;

    for (int i = 0; i < strlen(s); i++)
    {
        strcpy(s2, s);

        if (s[i] != ' ')
        {

            s2[i] = toupper(s2[i]); // Printing out `s2` here results in the correct output
            array[array_index++] = s2; // Adding it here works, but when trying to access it outside of this function, it gives the incorrect output
        }
    }
}

在函数内部打印字符串时，我得到以下输出(正确):

Hello
hEllo
heLlo
helLo
hellO

但是当我尝试在 main() 函数中打印出来时，我得到以下信息:

s = hellO
s = hellO
s = hellO
s = hellO
s = hellO

它似乎只添加/访问数组中的最后一个字符串。我不明白为什么访问 wave() 函数内的元素有效，但在该函数外访问它却不行。

这个问题我遇到过两次，C 和C++ 都解决不了，真是烦死我了。

Answer 1

我将其作为评论留下，但由于可能不清楚，我将在代码中发布我的答案...

如我的评论所述，分配指针数组毫无意义 - 在 64 位机器上，这将是 6 个指针，每个指针需要 8 个字节来指向一个 7 字节长的数据 block - 总共 104字节(忽略每次分配添加的分配器填充)。

相反，一次分配就足够了，分配 42 个字节以在单个内存块中包含所有“wave”字符串及其 NUL 字节(节省内存，同时改善局部性)。

int main(void) {
  /* Assuming string "hello" */
  const char *org = "hello";
  /* Calculate length only once and store value */
  const size_t len = strlen(org);
  const size_t len_with_nul = len + 1;
  /* Allocate `len` strings in a single allocation */
  char *buf = malloc(len * len_with_nul);
  /* Copy each string to it's place in the buffer */
  for (size_t i = 0; i < len; ++i) {
    /* position in the buffer */
    char *pos = buf + (i * len_with_nul);
    /* copy the NUL as well */
    memcpy(pos, org, len_with_nul); 
    /* Wave... */
    pos[i] = toupper(pos[i]);
  }
  /* Print result */
  for (size_t i = 0; i < len; i++) {
    char *pos = buf + (i * len_with_nul);
    printf("s = %s\n", pos);
  }
  /* Free buffer */
  free(buf);
  return 0;
}

编辑 - 为什么使用单个内存块更好？:

在这种情况下，我们分配单个内存“ block ”(blob/slice)。这提供了许多优势:

• 我们执行单次分配和释放，而不是大量的分配和释放。

  这通过执行更少的操作来提高速度。

• 我们还改进了内存局部性，which minimizes CPU cache misses and improves performance .

• 我们使用更少的内存。

  每个内存分配都有一个代价——我们需要一个指针来保存我们分配的内存的内存地址。指针在 64 位机器上“消耗”8 个字节，在 32 位机器上“消耗”4 个字节。

  通过使用单一分配，我们“支付”的更少。

  即使我们忽略附加到分配的内存块的元数据(这需要内存分配器的内存)也是如此。

我应该注意到 C 并不真正关心内存块的内容，它全是 0 和 1。赋予这些 0 和 1 的含义留给开发人员。

即使是 printf 函数也不关心它正在读取的内存内容 - 它只是根据开发人员指示的格式读取内存(% s 通知函数内存与一个以 NUL 结尾的字符串相关)。

有一些关于 CPU 和系统特定的内存对齐问题 - 但这些不适用于单字节字符串。它们适用于多字节类型(例如 short、int 和 long)。所以在这个例子中我们不需要担心它们。

从这个意义上说，它基本上意味着开发人员可以自由地管理他们认为合适的内存和内容(撇开内存对齐)。

这并不是说分配单个内存块总是更好(如果您需要使用 realloc，您可能更喜欢较小的 block )...但通常分配单个内存块更好。