C *p包含什么？

根据多个来源，指针

p

在解引用时指向某个值。因此，我们可以说指针包含一个地址作为其值，当使用解引用运算符（

*

）时，返回地址处的值

指针可以指定如下值：

inta=90；
int*p=&a

如果我们指定一个指针，它的值如下所示：

int*p；
*p=60

60分配给
p
，由于60不是有效地址，因此在解引用时会导致未定义的行为。（根据）

但是，对于以下代码：

    int a = 90;
    int *p = &a;

    printf ("p is %d \n",*p);
    printf ("a is %d \n", a);
    printf ("address is %p \n",p);

    *p = 100;

    printf ("p is %d \n",*p);
    printf ("a is %d \n", a);   
    printf ("address is %p \n",p);

int a = 90;
int *p = &a;

接收以下输出：

p是90

a是90

地址是0028FED8

p是100

a是100
地址是0028FED8

也就是说，表达式
*p=100
更改
a
处的值，而不是
p
所包含的值

怎么样

根据多个来源，指针
p
在解引用时指向某个值

不完全是。指针指向一个对象。取消对指针的引用将生成该对象。在需要值的上下文中使用对象会生成存储的值

p
现在指向的对象是
a

取消引用
p
将生成指向的对象，即
a
。由于这不是需要存储值的上下文，因此不会读取
a
的值，因此它仍然是分配值
100
的对象
a

或者，简单地说，
*p
意味着
a
，因此
*p=100
意味着
a=100
*p=&a甚至不编译。p是指向int的指针。它当前有一个未定义的值，因此将任何内容赋给*p都是未定义的行为，很可能会崩溃。然而，即使p确实指向int，您也只能将int赋值给*p，&a是指向int的指针，而不是int，因此这不会编译

在第二个示例中，*p=60，p的值是未定义的，因此您试图将60存储到内存中未定义的位置。瞬间崩溃。p没有被这个修改，所以你的解释是错误的。p未设置为60。不能将p设置为int。只能将其设置为指向int的指针

正确：

p = &a; 
*p = 60;

你曾问：

也就是说，表达式*p=100改变了a处的值，而不是p所包含的值

您可以阅读注释部分来解释每一行C代码，我没有使用确切的地址位置，而是使用任意地址位置进行演示：

int *p;       // Stack variable pointer to integer type w/ p's address being 4 bytes      @  0x00000000
int a = 90;   // Stack integer variable `a` and initializing it to the value of 90 located @  0x00000040 
*p = &a;      // Dereferencing the pointer `p` to be equal to the address of `a` ... One would think
              // that the address value of `a` 0x00000040 in hex would be stored into `a` which
              // has the value of 64 in decimal, however this is not always the case and this should be 
              // undefined behavior, but can still compile and run depending on the compiler and architecture. 
              // It may run or crash or not even compile or build at all. Most compilers should throw an error.

*p = 100;    // 'p' is located at 0x00000000 and contains the value 0x00000040 and by dereferencing it
             // it will assign the value of 100 to the stack address location of 0x00000040. Thus this
             // changes the value of `a` to 100

             // These two statements are in a sense equivalent  
*p = 100;    a = 100;
             // If one was to assign the address of `a` to `p` as such:
 p = &a;

编辑

            // Therefor the statement `*p=100` will only work if the statement
            // `p=&a` is defined and evaluated beforehand.

编辑
现在，关于基于标题的问题：
“p包含什么？”
提供了op的原始代码
*p
实际上包含垃圾或声明时分配给它的内容。
您在开始时编写的代码：

int *p;
int a = 90;
*p = &a;

无效，第1行中的星号（*）表示它是指针，而不是第3行中的解引用运算符

以下代码：

    int a = 90;
    int *p = &a;

    printf ("p is %d \n",*p);
    printf ("a is %d \n", a);
    printf ("address is %p \n",p);

    *p = 100;

    printf ("p is %d \n",*p);
    printf ("a is %d \n", a);   
    printf ("address is %p \n",p);

int a = 90;
int *p = &a;

相当于：

int a = 90;
int *p;
p = &a;

（p） 是指针，现在指向（a）的地址

所以，你只需要给a赋值，a=100。
您正在从同一地址打印相同的值。
*p=&a完全错误，任何体面的编译器都会拒绝它。要打印地址，请使用，而不是
%d
是的，它会被拒绝。我在这个问题上打错了。如果我错了，请纠正我，但C不是过程语言吗？C语言中没有对象，因为它不是一种面向对象语言。@simrandhamija没有，我的术语是对的，但我能理解它很混乱。C对对象的调用与OOP中的不同。C所调用的对象只是一块内存，通常是一个变量，或者是函数结果所指向的东西，比如
malloc
>，
a
的十六进制地址值将被存储到
a
@simrandhamija中，但这行代码是未定义的行为；我最初说地址值会存储为十六进制，但它的十进制等价值是64，因为变量类型是int。但事实并非如此。你的意思是“十六进制的
a
的地址值会存储到
p
”？@simrandhamija是的，如果语句是有效的，逻辑上会发生这种情况，但对于一些新手来说，他们可能会认为它会将实际值存储为十进制转换，但事实并非如此。@simrandhamija从注释部分中取出这句话，省略值为64的最后一部分
，即十进制，然后自己读句子的第一部分
人们会认为，十六进制格式的'a'（0x0…）的地址值将存储到'a'…
中，这与您在第一次和初始评论中回复我的内容是一样的。
*p = 100;