为什么指向 char 数组的指针必须需要 strcpy 才能将字符分配给其数组，而双引号分配不起作用？

Question

当你去删除指针时，第一个例子不起作用。当我添加空终止符时，程序要么挂起，要么没有它，我得到：

Debug Assertion Failed Expression: _BLOCK_TYPE_IS_VALID(pHead->nBlockUse) from Visual Studio 2008

//Won't work when deleting pointer:
    char *at = new char [3];
    at = "tw"; //   <-- not sure what's going on here that strcpy does differently
    at[2] = '\0'; // <-- causes program to hang
    delete at;

//Works fine when deleting pointer:
    char *at = new char [3];
    strcpy(at,"t");
    at[1] = 'w';
    at[2] = '\0';
    delete at;

那么当我使用双引号时会发生什么情况strcpy 的？它们都会完美地计算出字符串，并且调试器不会显示任何不同的内容。

Answer 1

当你这样做时，

char *at = ...;

at = "hello";

你基本上用静态常量字符串的地址覆盖了指针值（即由new[]为你分配的内存地址）。这意味着当您稍后删除该内存时，您将传递delete一个先前未由new返回的指针。

这是一件坏事。

在 C 和 C++ 中，对指针的赋值通常不会对所指向的内存执行任何操作，它们会更改指针本身。如果您习惯了字符串更多是“一等公民”的语言，这可能会令人困惑。

另外，如果您使用了 new[]，则应该使用 delete[]。

Answer 2

因为 char* 不是字符串。它只是一个指向某个字符的指针，约定可能有更多字符跟随，并且在最后一个字符之后有一个 '\0'。

C 中的字符串文字（因此在 C++ 中）如 "abc" 只是一个字符数组，编译器会默默地添加一个 '\0'。当您将数组分配给指针时，数组会默默地将指针转换为第一个元素。结果意味着

at = "tw";

，指针 at 被分配了字符串文字 "tw" 中第一个字符的地址。这样一来，它就失去了原有的价值。由于这是动态分配的字符数组的地址，因此您正在泄漏该数组。

当您稍后分配给 at 现在指向的数组中的字符时，您正在为字符串文字中的某个字符分配一个新值。这会调用未定义的行为，并且程序立即挂起或崩溃可能是您执行此操作时可能发生的最好情况。 （在许多平台上，您正在写入只读内存。）

稍后，您将 at 传递给 delete[] （以及 不是删除，因为您调用了new[]，而不是new）。这样做时，您将字符串文字的地址传递给它，而不是分配的字符数组。当然，这会弄乱堆管理器。 （VC 的运行时库在调试模式下捕获此情况。）

另一方面，std::strcpy 将字符串逐个字符地从一个数组复制到另一个数组。不会更改指针，只会复制内存片段。之后指向目标数组的指针仍然指向目标数组，只是该数组中的数据发生了变化。

让我补充一下：作为 C++ 初学者，您应该使用 std::string，而不是 C 字符串。它为您完成了所有脏活，并且具有合理的语义。

Answer 3

需要理解三件事：

1) char *at; 只是一个指针变量。
指针变量仅仅意味着它保存一个内存地址。

2) new char[3] 返回堆上分配的内存的起始地址。

3) "hello" 返回字符串文字的地址。

char *at = new char [3];
//at now contains the address of the memory allocated on the heap


at = "hello";
//at now contains the address of the static string. 
// (and by the way you just created a 3 byte memory leak)


delete[] at; 
//WOOPS!!!! you can't do that because you aren't deleting 
// the original 3 chars anymore which were allocated on the heap!
//Since at contains the string literal's memory address you're 
// trying to delete the string literal.

关于修改只读内存的注意事项：

此外，您永远不应该修改字符串文字。也就是说，永远不应该这样做：

char *at = "hello";
at[2] = '\0'; 

字符串文字的内存必须是只读的，如果更改它，C++ 语言将无法定义结果。

由于您使用的是 C++：

由于您使用的是 C++，请考虑改用 std::string 类型。

#include <string>

using namespace std;

int main(int argc, char **argv)
{
  string s = "hello";
  s += " world!";

  //s now contains "hello world!"

  s = "goodbye!";

  //Everything is still valid, and s contains "goodbye!"


  //No need to cleanup s. 

  return 0;
}

Answer 4

请不要忘记使用。

delete []

每当您使用 [] 分配某些内容时，

Answer 5

指针保存一个地址。指针的 = 运算符会更改所保存的地址。

at = "tw";

使 at 指向数组“tw”（编译器创建的用于保存字符 tw 的数组），它不再指向您用 new 创建的数组。文件中创建。

at[2] = '\0';

将 NULL 添加到编译器数组的末尾。

Answer 6

在第一个示例中，您正在更改 at 的值，在第二个示例中，您正在更改 at 指向的值。将 char * 分配给双引号字符串会将其分配给静态 const 指针。

特别是，在第一个示例中，现在指向内存中的不同位置。

Answer 7

在第一个示例中，您分配了一些内存并使用“at”变量指向它。当您这样做时，

at = "tw"

您实际上将 char * 重新指向常量字符串。这会导致你泄漏内存。当您继续删除“at”时，您正在尝试删除堆栈内存。

strcpy 遍历每个字符并将它们的值复制到您分配的新内存中。这也称为深层复制。

Answer 8

在第一个示例中，您导致了内存泄漏。

您的变量 at 是指向内存地址的指针，而不是字符串本身。当您将“tw”的地址分配给指针时，您就丢失了通过new获得的原始地址。 at 现在指向您未使用 new 分配的地址，因此您无法删除它。

如果您将指针视为整数，它可能会更有意义。为了讨论起见，我分配了任意数字作为地址。

char *at = new char[3];    // 0x1000
at = "tw";                 // 0x2000
at[2] = '\0';              // set char at 0x2002 to 0
delete at;                 // delete 0x2000 (whoops, didn't allocate that!)

Answer 9

您犯了两件事：使指针指向不同的东西（这就是赋值的作用）并将一些数据复制到指针指向的位置。

at = "tw";

此代码使 at 指向在只读内存中某处创建的文字“tw”。尝试写入它是一种未定义的行为。

char *at = new char [3];
strcpy(at,"t");

这段代码为三个字符分配内存，并使at指向这部分内存（第1行），然后将一些数据复制到at指向的内存。

请记住，使用 new[] 分配的内存应该使用 delete[] 来释放，而不是 delete

我建议您了解有关指针的更多信息。 此讨论 涵盖了这一点。