是什么在以下上下文指针和阵列之间的差异？

Question

#include <cstring> 
int main() 
    { 
    char *pName = new char[10]; 
    char dummy[] = "dummy"; 
    strcpy(pName + 0,dummy);//how this is different from -->this works 
    strcpy(pName[0],dummy);//this one...--> error C2664: 'strcpy' : 
          //cannot convert parameter 1 
          //from 'char' to 'char *' 

    } 

Answer 1

• PNAME [0]是在字符阵列（一个字符）
• PNAME是快捷方式& PNAME [0]（的一个指针数组的第一个元件）
第一元件

您得到您的错误的原因是因为strcpy的需要一个指向一个字符（字符*），而不是一个char值（这是什么PNAME [0]）

Answer 2

没有区别。由于您尚未为pName分配任何空间，因此它们都会崩溃。 ：编辑：不再是一个崩溃 - 问题已编辑]

主要区别是一个文体，经常影响它适合周围的代码编写的方式 - 主要是数组访问或主要是指针访问。

（编辑：假设你的真正用意& PNAME [0]布赖恩邦迪指出）

Answer 3

从技术上讲，strcpy(pName[0], dummy);是不正确的。即使内存分配给它。

这是因为pName[0]是'char'类型，而pName + 0是char *类型。他们都以不同的方式引用相同的记忆。

编译器可以再打开strcpy(pName[0], dummy);成strcpy((char*) pName[0], dummy);这是一种危险的隐式转换。如果你的编译器是像样的，你会得到一个警告或错误（当你与你的“错误C2664”看到）。

Answer 4

阵列是简单地自动地（通常）分配给存储器的自动分配块的指针。以你的例子，你可以声明虚同样为：

char dummy[] = "dummy"; 
char *dummy = "dummy"; 

然后你就可以使用数组语法或指针语法来访问数据：

char ch = dummy[0]; // get the first element of the array 
char ch = *dummy;  // get the data pointed to by dummy 

两个[]和*可以去重新使用-reference指针和数组，所以下面是等效的：

array[N]; 
*(ptr + N); 

鉴于第二种形式中，仍然​​是一个指针，只是˚F进一步沿阵列。这就是为什么你的例子在语法上是正确的。 ptr[N]是指针的去参考和为char（在此上下文中）。

Answer 5

PNAME是指向新分配的内存。 char *pName = new char[10];

dummy也是一个数组/指针。 char dummy[] = "dummy";

pName是指针并指向基地址，即使您添加（pName + 0）仍然指向相同的内存位置，因为您只能添加0。strcpy(pName + 0,dummy);

的strcpy使用指针变量，并在第一个参数的传递价值，因此你越来越错误strcpy(pName[0],dummy)

Answer 6

当使用C或C指针和数组处理++它确实有助于承认他们是非常明显的结构（我认为解释这种区别的最好的书之一是一本叫做“Deep C Secrets”的书，如果我没有记错的话）。泥水是这样一个事实：从数组名到指针有一种单向的无声转换（语言处理变量名称时出现不一致） - 但是不要将这种衰减现象的存在解释为暗示等价。

为了帮助我们有理由这一点，让我们介绍一个“存储单元”的想法。我们一个“存储单元”模式具有两个属性：

a) value 
b) address 

然后，我们可以模拟一个简单的C++为具有两个属性变量（我们不抽象的这种低层次需要的类型）：

c) name 
d) memory cell 

与大多数模型一样，它有一些缺陷（不涉及具有多个元素的数组，但它对我们的目的来说足够了）。

因此，例如：

// non-array variable: name 'i', and memory cell: value=3, address=0x0A 
int i = 3; 

// non-array variable: name 'p', and memory cell: value=0x0A, address=0x0B 
int *p = &i; 

// array variable: name 'a', and memory cell: vale=4, address=0x0C  
int a[1] = { 4 }; 

// non-array variable: name 'b', and memory cell: value=0x0C, address = 0x0D 
int (*b)[1] = &a; 

// non-array variable: name 's', and memory cell: value=0x0C, address = 0x0E 
int *s = &a[0]; 


// non-array variable: name 't', and memory cell: value=0x0C, address = 0x0F 
int *t = a; // Here is the key difference! read on... 

现在，这里的一个数组变量和非阵列之间的主要区别（指针）C++变量：

当在C++中的变量名称进行评价时，它总是评估其存储单元的值，但有一个例外：如果该变量命名一个数组变量。
如果变量是它的计算结果为所述存储单元的地址阵列的名称。
以上两行值得再读一遍。

下面是一些例子，以帮助澄清的影响（参照上述变量）：

int k = i; // the 'i' name evaluates to the value of its cell, so 'k' is set to 3 

int *q = p; // 'p' evaluates to the value of its cell, so 'q' is set to 0x0A 

int *r = a; // 'a' evaluates to the *address* of its cell, so 'r' is set to 0x0C 

int (*c)[1] = b; // 'c' is set to 0x0D 

这绝不应意味着一个数组变量是相同作为指针变量。
它们具有固有的不同类型，并且试图将它们当作相同的（即，将变量名称定义为一个翻译单元中的数组，并且作为另一个翻译单元中的指针）会导致不好的事情发生。

因此对于例如不要这样做：

 
// myproj_file1.cpp 
int array[100] = { 0 }; // here 'array' evaluates to the *address* of the first memory cell 

// myproj_file2.cpp 
extern int* array; // here 'array' evaluates to the *value* of the first memory cell 
      // Assuming the linker links the two 
      // what it does if you read the assembly, is something like this: 
      // extern int* array = (int*) array[0]; 
      // but it doesn't have to, it can do anything, since the behavior is undefined 

我希望这有助于。 如果你还是觉得进一步澄清也许会有帮助，请询问后续问题，不要犹豫，拿到“深度C的秘密”一书:)

复印件（库） -
附：功能类型及其名称和衰减与这篇文章的大部分无关
p.s.我也故意忽略当数组绑定到引用类型时不会发生数组到指针的转换