在以下上下文中，指针和数组之间有什么区别？

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（char*），而不是char值（这是pname [0]是）

Answer 2

在处理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

这绝不应该暗示数组变量是 相同的 作为指针变量。
他们天生有不同的类型，并且任何试图将它们视为 相同的 （IE将变量名称定义为一个翻译单元中的数组，而将变量名称定义为另一个指针）将导致不良的事情发生。

因此，例如不要这样做：

// 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秘密”书的副本（库）：）

--
PS功能类型及其名称及其衰减与本文的大多数无关
PS我还故意忽略了数组转换在数组绑定到参考类型时不会发生

Answer 3

从技术上讲， strcpy(pName[0], dummy); 不正确。即使为此分配了内存。

这是因为 pName[0] 是类型的“ char” pName + 0 是类型char*。他们都以不同的方式引用相同的内存。

然后，编译器可以转动 strcpy(pName[0], dummy); 进入 strcpy((char*) pName[0], dummy); 这是一个危险的隐性演员。如果您的编译器是一半，您会收到警告或错误（因为您看到“错误C2664”）。

Answer 4

没有区别。它们都会崩溃，因为您没有为pname分配任何空间。 :) [编辑：不再崩溃 - 已经编辑了问题

主要区别是一种风格上的区别，经常受到拟合周围代码的编写方式的影响 - 主要是数组访问或大多是指针访问。

（编辑：假设您的意思是＆pname [0]，正如布莱恩·邦迪（Brian Bondy）指出的那样。）

Answer 5

数组只是自动（通常）分配给自动分配的内存块的指针。以您的示例，您可以同样声明假人为：

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

两个都 [] 和 * 可以使用重新引用的指针和数组，因此以下是等效的：

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

给定第二个形式， (ptr + N) 仍然是一个指针，沿着阵列更远。这就是为什么在您的示例中句法正确的原因。 ptr[N] 是指针的解读，是一个字符（在这种情况下）。

Answer 6

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

虚拟也是阵列/指针。 char dummy[] = "dummy";

pname是指针，指向基础地址，即使您添加（pname + 0）仍指向同一内存位置，因为您唯一添加0。 strcpy(pName + 0,dummy);

strcpy使用指针变量和您在第一个参数中的传递值，因此您正在遇到错误 strcpy(pName[0],dummy)