指针与普通指针的对比

指针的目的是保存特定变量的地址。然后，以下代码的内存结构应类似于：

int a = 5;
int *b = &a;

......内存地址......值 a ... 0x000002
................... 5
b ... 0x000010 ..... .............. 0x000002

好的。然后假设现在我要保存指针* b的地址。然后我们通常将双指针** c定义为

int a = 5;
int *b = &a;
int **c = &b;

然后，内存结构如下所示：

......内存地址......值 a ... 0x000002
................... 5
b ... 0x000010 ..... .............. 0x000002
c ... 0x000020 ................... 0x000010

因此，** c表示* b的地址。

现在我的问题是，为什么要使用这种类型的代码，

int a = 5;
int *b = &a;
int *c = &b;

产生警告？

如果指针的目的只是保存内存地址，我想如果我们要保存的地址是指变量，指针，双指针等，则应该没有层次结构，因此以下类型的代码应该有效。

int a = 5;
int *b = &a;
int *c = &b;
int *d = &c;
int *e = &d;
int *f = &e;

在

int a = 5;
int *b = &a;   
int *c = &b;

您会收到警告，因为&b它是类型的int **，并且您尝试初始化类型的变量int *。这两种类型之间没有隐式转换，从而导致警告。

举一个较长的例子，您想工作，如果我们尝试取消引用，f则编译器会给我们一个int，而不是我们可以进一步取消引用的指针。

还要注意，在许多系统上int，int*它们的大小并不相同（例如，指针的长度可能为64位，而长度可能为int32位）。如果取消引用f并获得int，则会丢失一半的值，甚至无法将其强制转换为有效的指针。

如果指针的目的仅仅是保存内存地址，我想如果我们要保存的地址是变量，指针，双指针等，则应该没有层次结构。

是的，在运行时，指针仅保存一个地址。但是在编译时，每个变量都有一个类型。正如其他人所说的，int*并且int**是两种不同的不兼容类型。

有一种类型的void*可以满足您的需求：它只存储一个地址，您可以为其分配任何地址：

int a = 5;
int *b = &a;
void *c = &b;

但是，当您要取消引用a时void*，您需要自己提供“缺少”类型的信息：

int a2 = **((int**)c);

现在我的问题是，为什么要使用这种类型的代码，

int a = 5; 
int *b = &a; 
int *c = &b; 

产生警告？

您需要回到基础知识。

• 变量有类型
• 变量保存值
• 指针是一个值
• 指针指向变量
• 如果p是指针值，*p则为变量
• 如果v是变量，则&v是指针

现在，我们可以在您的帖子中查找所有错误。

然后假设现在我要保存指针的地址 *b

No.*b是int类型的变量。它不是指针。b是一个变量，其值为指针。 *b是一个值为整数的变量。

**c指的地址*b。

不不不。绝对不。你必须要正确理解这一点，如果你要了解的指针。

*b是一个变量；它是变量的别名a。变量的地址是变量a的值b。 **c没有引用的地址a。相反，它是一个变量，其为别名为变量a。（也是*b。）

正确的说法是：值变量c是地址的b。或者，等效地：的值c是指向的指针b。

我们怎么知道呢？回到基本面。你这么说c = &b。那么，什么是价值c？指针。要什么 b。

确保您完全了解基本规则。

现在，您希望了解变量和指针之间的正确关系，您应该可以回答有关代码为什么会出错的问题。

如果您想获得正确的警告并且希望代码完全进行编译，则C的类型系统需要这样做。仅使用一个深度的指针，您就不会知道指针是指向指针还是实际整数。

如果取消引用类型int**，则知道获得的类型，int*而如果取消引用int*类型，则类似int。根据您的建议，类型将是不明确的。

从您的示例来看，不可能知道是否c指向aint或int*：

c = rand() % 2 == 0 ? &a : &b;

c指向什么类型？编译器不知道，因此下一行是无法执行的：

*c;

在C语言中，所有类型信息在编译后都会丢失，因为每种类型都在编译时检查，并且不再需要。您的建议实际上会浪费内存和时间，因为每个指针都必须具有有关指针中包含的类型的其他运行时信息。

指针是抽象的具有附加类型语义的内存地址的，并且在类似C类型的语言中很重要。

首先，有没有保证，int *和int **具有相同的尺寸或代表（他们做现代桌面架构，但你不能依赖它被普遍正确的）。

其次，类型对于指针算术很重要。给定p类型的指针T *，表达式p + 1产生类型下一个对象的地址T。因此，假定以下声明：

char  *cp     = 0x1000;
short *sp     = 0x1000;  // assume 16-bit short
int   *ip     = 0x1000;  // assume 32-bit int
long  *lp     = 0x1000;  // assume 64-bit long

该表达式cp + 1为我们提供了下一个char对象的地址，即0x1001。该表达式sp + 1为我们提供了下一个short对象的地址，即0x1002。 ip + 1给我们0x1004，lp + 1给我们0x1008。

所以，给定

int a = 5;
int *b = &a;
int **c = &b;

b + 1让我们接下来的地址int，并c + 1给我们的下一个地址指针，以int。

如果要让函数写入指针类型的参数，则需要指针对指针。采取以下代码：

void foo( T *p )    
{
  *p = new_value(); // write new value to whatever p points to
}

void bar( void )
{
  T val;
  foo( &val );     // update contents of val
}

这是真正的任何类型T。如果我们将其替换T为指针类型P *，则代码变为

void foo( P **p )    
{
  *p = new_value(); // write new value to whatever p points to
}

void bar( void )
{
  P *val;
  foo( &val );     // update contents of val
}

语义完全相同，只是类型不同而已。形式参数p总是比变量多一个间接级别val。

我认为如果要保存的地址引用变量，指针，双指针，则应该没有层次结构

如果没有“层次结构”，那么很容易在没有任何警告的情况下全面生成UB-这将是可怕的。

考虑一下：

char c = 'a';
char* pc = &c;
char** ppc = &pc;
printf("%c\n", **ppc);   // compiles ok and is valid
printf("%c\n", **pc);    // error: invalid type argument of unary ‘*’

编译器给我一个错误，因此可以帮助我知道我做错了什么，并且可以纠正错误。

但是没有“层次结构”，例如：

char c = 'a';
char* pc = &c;
char* ppc = &pc;
printf("%c\n", **ppc);   // compiles ok and is valid
printf("%c\n", **pc);    // compiles ok but is invalid

编译器不会给出任何错误，因为没有“层次结构”。

但是当行：

printf("%c\n", **pc);

执行，它是UB（未定义行为）。

首先*pc读取char就好像它是一个指针一样，即即使我们仅保留1个字节，也可能读取4或8个字节。那是UB。

如果程序没有由于上面的UB而崩溃，而只是返回了一些垃圾值，那么第二步将是取消引用垃圾值。UB。

结论

类型系统通过将int *，int **，int ***等视为不同类型来帮助我们检测错误。

如果指针的目的仅仅是保存内存地址，我想如果我们要保存的地址是变量，指针，双指针等，则应该没有层次结构，因此下面的代码类型应该是有效的。

我认为这是您的误解：指针本身的目的是存储内存地址，但是指针通常也具有类型，以便我们知道指针所指向的位置。

特别是，与您不同，其他人确实希望拥有这种层次结构，以便知道如何处理指针所指向的内存内容。

C的指针系统的重点就是附加类型信息。

如果你这样做

int a = 5;

&a意味着您得到的是一个，int *因此，如果取消引用，它又是一个int。

将其带入新的高度，

int *b = &a;
int **c = &b;

&b也是一个指针。但是，不知道它背后隐藏着什么，分别。它指向的是没有用的。重要的是要知道取消对指针的引用会揭示原始类型的类型，因此它*(&b)是一个int *，并且**(&b)是int我们使用的原始值。

如果您觉得在您的情况下应该没有类型层次结构，则可以始终使用void *，尽管直接可用性非常有限。

如果指针的目的仅仅是保存内存地址，我想如果我们要保存的地址是变量，指针，双指针等，则应该没有层次结构，因此下面的代码类型应该是有效的。

嗯，这对于机器是正确的（毕竟，几乎所有东西都是数字）。但是在许多语言中，变量是类型化的，这意味着编译器可以确保正确使用它们（类型将正确的上下文强加给变量）

的确，指向指针的指针和指针（可能）使用相同数量的内存来存储其值（请注意，对于int和指向int的指针而言，这不是正确的，地址的大小与a的大小无关。屋）。

因此，如果您有一个地址的地址，则应按原样使用而不是一个简单的地址，因为如果您将指向指针的指针作为一个简单的指针访问，那么您将能够操纵int的地址，就好像它是一个int一样。 ，但不是（不要将int替换为其他任何东西，您应该会看到危险）。您可能会因为所有这些都是数字而感到困惑，但是在日常生活中却没有：我个人对1美元和1美元的狗有很大的帮助。dog和$是类型，您知道可以使用它们做什么。

您可以进行汇编编程并完成所需的操作，但是您会发现它有多危险，因为您几乎可以执行所需的操作，尤其是奇怪的事情。是的，修改地址值是危险的，假设您有一辆自动驾驶汽车，应在以距离表示的地址处传送东西：1200条记忆街（地址），并假定街道房屋之间相距100英尺（1221是无效地址），如果您能够按自己喜欢的方式操作地址（作为整数），则可以尝试在1223传递，并将数据包放在人行道的中间。

另一个示例可能是房屋，房屋地址，该地址的通讯录中的条目号。这三个都是不同的概念，不同的类型...

有不同的类型。这是有充分的理由的：

有...

int a = 5;
int *b = &a;
int **c = &b;

… 表达方式 …

*b * 5

…有效，而表达式…

*c * 5

没有意义。

大不了就是没有，怎么指针或指针到指针存储，但什么他们参考。

C语言是强类型的。这意味着，对于每个地址，都有一个type，它告诉编译器如何解释该地址处的值。

在您的示例中：

int a = 5;
int *b = &a;

的类型a为int，类型b为int *（称为“指向”的指针int）。使用您的示例，内存将包含：

..... memory address ...... value ........ type
a ... 0x00000002 .......... 5 ............ int
b ... 0x00000010 .......... 0x00000002 ... int*

该类型实际上并没有存储在内存中，只是编译器知道，当您阅读时，a您会发现一个int，而当您阅读时，b您将找到一个可以找到的地址int。

在第二个示例中：

int a = 5;
int *b = &a;
int **c = &b;

的类型 c为int **，称为“指向的指针int”。这意味着对于编译器：

• c 是一个指针；
• 当您阅读时c，您将获得另一个指针的地址；
• 当您读取另一个指针时，您将获得一个 int。

那是，

• c 是一个指针（int **）;
• *c 也是一个指针（int *）;
• **c 是一个 int。

内存将包含：

..... memory address ...... value ........ type
a ... 0x00000002 .......... 5 ............ int
b ... 0x00000010 .......... 0x00000002 ... int*
c ... 0x00000020 .......... 0x00000010 ... int**

由于“类型”不与值一起存储，并且指针可以指向任何内存地址，因此编译器知道地址中值类型的方式基本上是通过获取指针的类型并删除最右边的 *。

顺便说一下，这是针对常见的32位体系结构的。对于大多数64位体系结构，您将具有：

..... memory address .............. value ................ type
a ... 0x0000000000000002 .......... 5 .................... int
b ... 0x0000000000000010 .......... 0x0000000000000002 ... int*
c ... 0x0000000000000020 .......... 0x0000000000000010 ... int**

现在，每个地址都是8个字节，而地址int仍然只有4个字节。由于编译器知道每个变量的类型，因此可以轻松处理此差异，并为指针读取8个字节，为读取4个字节int。

为什么这种类型的代码会产生警告？

int a = 5;
int *b = &a;   
int *c = &b;

的&操作者产生一个指向对象，即&a是类型的int *左右（通过初始化）在分配给b这也是类型int *是有效的。&b产生一个指向object的指针b，该&b指针的类型为int *，即int **。

C在赋值运算符（用于初始化的条件）的约束中说（C11，6.5.16.1p1）：“两个操作数都是指向兼容类型的合格或不合格版本的指针”。但是在C中定义什么是兼容类型int **，int *哪些不是兼容类型。

因此，在 int *c = &b;初始化过程中这意味着编译器需要进行诊断。

该规则的基本原理之一是标准未保证两种不同的指针类型具有相同的大小（void *和字符指针类型除外），即sizeof (int *)并且sizeof (int **)可以是不同的值。

那是因为任何指针T*实际上都是类型pointer to a T（或address of a T），其中的指针指向T类型。在这种情况下，*可以读取为pointer to a(n)，并且T是指向类型。

int     x; // Holds an integer.
           // Is type "int".
           // Not a pointer; T is nonexistent.
int   *px; // Holds the address of an integer.
           // Is type "pointer to an int".
           // T is: int
int **pxx; // Holds the address of a pointer to an integer.
           // Is type "pointer to a pointer to an int".
           // T is: int*

这用于取消引用的目的，其中取消引用运算符将​​采用T*，并返回类型为的值T。返回类型可以看作是截断最左边的“指向a（n）的指针”，并且是剩下的任何东西。

  *x; // Invalid: x isn't a pointer.
      // Even if a compiler allows it, this is a bad idea.
 *px; // Valid: px is "pointer to int".
      // Return type is: int
      // Truncates leftmost "pointer to" part, and returns an "int".
*pxx; // Valid: pxx is "pointer to pointer to int".
      // Return type is: int*
      // Truncates leftmost "pointer to" part, and returns a "pointer to int".

请注意，对于上述每个操作，解引用运算符的返回类型如何与原始T*声明的T类型匹配。

这极大地帮助了原始编译器和程序员解析指针的类型：对于编译器，address-of运算符*向该类型添加a ，解引用运算符*从该类型中删除a ，并且任何不匹配都是错误。对于程序员而言，*s的数量直接表明您正在处理多少个间接寻址级别（int*始终指向int，float**始终指向float*，依次指向始终指向float等等）。

现在，考虑到这一点，*无论间接级别的数量如何，仅使用单个存在两个主要问题：

1. 对于编译器而言，指针要解除引用的难度要大得多，因为指针必须返回最新的赋值以确定间接级别，并适当地确定返回类型。
2. 对于程序员而言，指针更难理解，因为很容易失去对间接访问层数的跟踪。

在这两种情况下，确定该值的实际类型的唯一方法是回溯该值，迫使您在其他地方查找它。

void f(int* pi);

int main() {
    int x;
    int *px = &x;
    int *ppx = &px;
    int *pppx = &ppx;

    f(pppx);
}

// Ten million lines later...

void f(int* pi) {
    int i = *pi; // Well, we're boned.
    // To see what's wrong, see main().
}

这是一个非常危险的问题，可以通过使*s的数目直接表示间接级别来轻松解决。