为什么我不能使用 `=` 复制数组？

Question

我开始通过阅读 K&R 并完成一些练习来学习 C。经过一番折腾，我终于用下面的代码完成了练习1-19：

/* reverse: reverse the character string s */
void reverse(char s[], int slen)
{
  char tmp[slen];
  int i, j;

  i = 0;
  j = slen - 2;    /* skip '\0' and \n */

  tmp[i] = s[j];
  while (i <= slen) {
    ++i;
    --j;
    tmp[i] = s[j];
  }

  /* code from copy function p 29 */
  i = 0;
  while ((s[i] = tmp[i]) != '\0')
    ++i;

}

我的问题是关于将tmp 字符数组复制到s 的最后一段代码。为什么简单的s = tmp; 不起作用？为什么必须逐个索引地遍历数组复制？

Answer 1

也许我只是又老又脾气暴躁，但我看到的其他答案似乎完全没有抓住重点。

C 不做数组赋值，句号。与其他一些语言不同（例如，PL/1；Pascal 及其许多后代——Ada、Modula、Oberon 等），您不能通过简单的赋值将一个数组分配给另一个数组。 C 也没有真正的字符串类型。它只有字符数组，如果不使用循环或函数调用，就不能复制字符数组（就像复制任何其他类型的数组一样）。 [字符串字面量并不真正算作字符串类型。]

复制数组的唯一时间是当数组嵌入到结构中并且您执行结构分配时。

在我的 K&R 第 2 版副本中，练习 1-19 要求函数 reverse(s)；在我的 K&R 第 1 版副本中，它是练习 1-17 而不是 1-19，但提出了相同的问题。

由于在这个阶段还没有涉及到指针，所以解决方案应该使用索引而不是指针。我相信这会导致：

#include <string.h>
void reverse(char s[])
{
    int i = 0;
    int j = strlen(s) - 1;
    while (i < j)
    {
        char c = s[i];
        s[i++] = s[j];
        s[j--] = c;
    }
}

#ifdef TEST
#include <stdio.h>
int main(void)
{
    char buffer[256];
    while (fgets(buffer, sizeof(buffer), stdin) != 0)
    {
        int len = strlen(buffer);
        if (len == 0)
            break;
        buffer[len-1] = '\0';  /* Zap newline */
        printf("In:  <<%s>>\n", buffer);
        reverse(buffer);
        printf("Out: <<%s>>\n", buffer);
    }
    return(0);
}
#endif /* TEST */

使用 -DTEST 编译它以包含测试程序，而无需定义函数 reverse()。

使用问题中给出的函数签名，您可以避免每行输入两次调用strlen()。注意fgets() 的使用——即使在测试程序中，使用gets() 也是一个坏主意。 fgets() 与 gets() 相比的缺点是 fgets() 不会像 gets() 那样删除尾随换行符。 fgets() 的好处是您不会遇到数组溢出，并且您可以在遇到换行符之前判断程序是否找到了换行符或者是否空间（或数据）不足。

Answer 2

您的tmp 数组已在stack 上声明，因此当您的方法完成时，用于保存值的内存将因scoping 而被释放。

s = tmp 表示s 应该指向与tmp 相同的内存位置。这意味着当tmp 被释放时，s 仍将指向一个现在可能无效的、已释放的内存位置。

这种类型的错误称为dangling pointer。

编辑：这不是这个答案的 cmets 中指出的悬空修饰符。问题是 s = tmp 只会改变参数指向的内容，而不是实际传递的数组。

此外，您可以一次执行反向操作，而无需在内存中分配整个数组，只需将值一个一个交换到位：

void reverse(char s[], int slen) {
    int i = 0;        // First char
    int j = slen - 2; // Last char minus \n\0
    char tmp = 0;     // Temp for the value being swapped

    // Iterate over the array from the start until the two indexes collide.
    while(i < j) {
        tmp = s[i];  // Save the eariler char
        s[i] = s[j]; // Replace it with the later char
        s[j] = tmp;  // Place the earlier char in the later char's spot
        i++;         // Move forwards with the early char
        j--;         // Move backwards with the later char
    }
}

Answer 3

因为 s 和 tmp 都是内存地址。如果你 s = tmp，两个指针都会指向同一个数组。

假设我们有

char s[] ="ab"; 

/*
* Only for explanatory purposes.
* 
*/
void foo(char s[]){ 
    char tmp [] = "cd";
    s= tmp;
 }

foo(s);

在 s=tmp 之后，你会拥有

s[0] : 'c'
s[1] : 'd'
s[2] : '\0'

即使两个数组具有相同的数据，tmp 的变化也会影响它们，因为两个数组实际上是相同的。它们都包含相同内存地址中的数据。所以通过改变 tmp 数组的任意位置，或者破坏 tmp 数组，s 都会受到同样的影响。

通过遍历数组，您所做的就是将一段数据从一个内存地址移动到另一个内存地址。

在我的 K&R 副本中，第 4 章解释了指针。快速浏览第一页可能会有所帮助。

Answer 4

为了结束这里的讨论，还有另外两种可能的反转为字符串的方法：

void reverse(char string1[], char string2[])
{
  int i = 0, len = 0;

  while(string2[len] != '\0')   // get the length of the string
      len++;

  while(len > 0)
  {
    string1[i] = string2[len-1]; // copy the elements in reverse
    i++;
    len--;
  }
  string1[i] = '\0'; // terminate the copied string 
}

或递归：

void reverse (const char *const sPtr)
{
  //if end of string
  if (sPtr[0] == '\0')
  {
    return;
  }
  else  //not end of the string...
   {
    reverse(&sPtr[1]);  //recursive step
    putchar(sPtr[0]);   //display character
   }
}

Answer 5

因为 tmp 是一个指针，你需要得到一个副本，而不是一个“链接”。

Answer 6

在 s=tmp 的情况下，tmp 的值也是数组的起始地址，将被复制到 s。

这样 s 和 tmp 都会指向内存中的同一个地址，我认为这不是目的。

干杯

Answer 7

尝试进行实验，看看当你这样做时会发生什么：

void modifyArrayValues(char x[], int len)
{
    for (int i = 0; i < len; ++i)
        x[i] = i;
}

void attemptModifyArray(char x[], int len)
{
    char y[10];
    for (int i = 0; i < len; ++i)
        y[i] = i;
    x = y;
}


int main()
{
    int i = 0;
    char x[10];
    for (i = 0; i < 10; ++i)
        x[i] = 0;

    attemptModifyArray(x, 10);
    for (i=0; i < 10; ++i)
        printf("%d\n", x[i]); // x is still all 0's

    modifyArrayValues(x, 10);
    for (i=0; i < 10; ++i)
        printf("%d\n", x[i]); // now x has 0-9 in it
}

当您直接在attemptModifyArray 中修改数组时会发生什么，您只是覆盖了数组x 的地址的本地副本。当您返回时，原始地址仍在main 的x 副本中。

当您修改modifyArrayValues 中数组中的值时，您正在修改实际数组本身，该数组的地址存储在modifyArrayValues 的本地副本x 中。当您返回时，x 仍然保留同一个数组，但您已经修改了该数组中的值。

Answer 8

这个线程中有一个关于数组和指针的有趣子线程 我在维基百科上找到了this link，上面有一个特殊的代码 sn-p，它显示了“橡皮泥”C 的含义！

/* x designates an array */
x[i] = 1;
*(x + i) = 1;
*(i + x) = 1;
i[x] = 1; /* strange, but correct: i[x] is equivalent to *(i + x) */

当然，在 C 语言中更令人困惑的是我可以这样做：

unsigned int someval = 0xDEADD00D;
char *p = (char *)&someval;

p[2] = (char)0xF0;

因此，指针和数组的互换性在 C 语言中似乎根深蒂固，几乎是有意为之。
其他人怎么看？

---原帖---
s 和 tmp 都是指针，因此执行 s = tmp 只会使 s 指向 tmp 在内存中的地址。
您概述的另一个问题是 tmp 是一个局部变量，因此当它超出范围时（即函数返回时）将变为“未定义”。

确保你彻底掌握这三个概念，你不会走错路

1. 范围
2. 栈和堆的区别
3. 指针

希望有所帮助并继续前进！

Answer 9

一个非常直接的答案是 - s 和 tmp 都是指向内存位置的指针，而不是数组本身。 换句话说，s 和 tmp 是存储数组值的内存地址，而不是值本身。 访问这些数组值的常用方法之一是使用 s[0] 或 tmp[0] 等索引。

现在，如果您尝试简单地复制 s = tmp，则 tmp 数组的内存地址将被复制到 s。这意味着，原来的 s 数组将丢失，甚至 s 内存指针现在将指向 tmp 数组。

您将在适当的时候很好地理解这些概念，因此请继续阅读本书。 我希望这个基本解释会有所帮助。