关于指针和内存地址的困惑

Question

好吧，我在这里看一个代码，这个想法很难理解。

#include <iostream> 
using namespace std; 
class Point 
{ 
public : 
    int X,Y; 
    Point() : X(0), Y(0) {} 
}; 

void MoveUp (Point * p) 
{ 
    p -> Y += 5; 
} 

int main() 
{ 
    Point point; 
    MoveUp(&point); 
    cout << point.X << point.Y; 
    return 0; 
} 

好了，所以我认为，一类是创建和X和Y宣布，它们被放置在构造函数中

创建方法和参数是点* P，这意味着我们将要把构造函数的指针粘贴在函数内部;

现在我们创建一个名为point的对象，然后调用我们的方法并将指针地址放在里面？

是不是指针地址只是一个内存号码像0x255255？

为什么没有声明？

(int * p = Y) 

什么是内存地址？它可以用作参数？

Answer 1

p被宣布声明。

void MoveUp (Point * p) 
{ 
    p -> Y += 5; 
} 

是，将采取一个指向Point并加入5到其Y值的函数。这是下面的没有什么不同：

void f(int n) { 
    printf ("%d\n", n); 
} 
: 
int x = 7; 
f(x); 

n并没有在这种情况下定义，你不会说。你的情况与p一样。

也许在代码中的一些意见将帮助：

#include <iostream> 
using namespace std; 
class Point 
{ 

public : 
    int X,Y; 
    Point() : X(0), Y(0) {}  // Constructor sets X and Y to 0. 
}; 

void MoveUp (Point * p)   // Take a Point pointer p. 
{ 
    p -> Y += 5;     // Add 5 to its Y value. 
} 
int main() 
{ 
    Point point;     // Define a Point. 
    MoveUp(&point);    // Call MoveUp with its address. 
    cout <<point.X << point.Y; // Print out its values (0,5). 
    return 0; 
} 

指针就是间接的级别。在代码中：

1 int X; 
2 int *pX = &X; 
3 X = 7; 
4 *pX = 7; 

第3行和第4行的效果是相同的。这是因为pX是X的指针，所以*pX,pX的内容实际上是X。

对于您的情况，p->Y与(*p).Y相同，或p指向的类的Y成员相同。

Answer 2

指针只是一个像其他任何变量一样的变量，但它包含一个内存地址。
阅读该行约6次。名字指针本身对人们来说似乎很可怕，但实际上这只是为了让自己更容易思考发生了什么。

指针的类型（例如char *，int *，Point *）只是告诉编译器存储在该内存地址的内容。

所以所有的指针都是一样的，因为它们都存储一个简单的内存地址。但是它们的区别在于指针的类型会告诉你该内存地址中包含的内容。

为什么没有声明？

p被声明：

//p is declared to be a variable that holds an address 
// and at that address it holds a type Point 
//p itself only holds an address not the actual data of the Point. 
void MoveUp (Point * p) 
{ 
    //The -> operator when applied to a pointer, means give me the object at 
    // that address and then access the following member 
    p->Y += 5; 
} 

---

什么是存储ADDRES是什么呢？它可以用作参数？

你可以简单地把一个存储地址想象成一个数字。在32位程序上，这个数字是4个字节长。在64位程序中，这个数字是8个字节长。

---

考虑下面的代码：

Point point; 
Point *p = &point; 

的point变量是Point类型。它拥有类Point的一个对象。
&point表达式返回Point变量point的地址。表达式&point的类型是Point*。
p变量保存类型为Point的地址，p的类型为Point*。p在对象point的内存中保存地址。

Answer 3

P在函数定义

void MoveUp (Point * p) 

Answer 4

在你看指针之前，你必须先澄清“class”，“instance”和“constructor”的含义。你的句子

，创建一类和X和Y 宣布，他们正在把 构造

里面显示了这种澄清的必要。以下是关于您可能需要阅读的书籍的讨论：Books to refer for learning OOP through C++

Answer 5

将内存视为连续的小块。

现在，将Point类视为2块宽度的东西，然后将它放在内存中的任何位置。在哪里并不重要，重要的是，它只能放在一个起点上。您可以移动它并更改该起始点，但不可撤销地将从一个起点开始。

然后指针是那个ONE起始点的数量。

当你传递一个指针作为参数，你在干什么

• 你：“哎功能，拿这点和你知道什么”
• 功能：'好的，但是Point！在哪里？'
• 你：'哦，对不起，我不把它和我一起，它位于那里，在那个街区！'

而函数会知道现在有一个Point，并且用编译器的魔法，函数会知道它的2个block的宽度。然后函数接受它，改变它的Y（再次感谢，编译器），并将它留在原来的位置（事实上，它甚至没有把它从那里拿走）。 几分钟后，你去那里，看到Point.Y已经改变。你说'谢谢'，然后你走了。

Answer 6

p被声明为方法参数。

指针是一种特殊的变量，它保存一个值的内存地址。 *符号是取消引用符号，它告诉您的代码查找指针保存的内存地址中的值IN。现在也是介绍&符号的好时机，它会告诉您的代码获取值的内存地址。例如：

int i = 5; //int 
int *pointer; //int pointer 

pointer = &i; //sets pointer to the memory address of i 

doMath(&i); //passes a memory address, value inside that address is being used 
doMath(pointer); //same as above 
dontMath(i); //value of x will be 207, value of i is still 7 since a copy is being modified 

//value of pointer is a memory address 
//value of *pointer is the value stored inside that memory address, 7 
//value of &pointer is the memory address of pointer, which itself holds the memory address 


void doMath(int *p) { 
    *p++; 
} 
void dontMath(int x){ 
    x=x+200; 
} 

我早期的困惑是*符号的含义。在变量声明中，这意味着你正在为某个数据类型（一个包含内存地址的变量）声明一个指针。在其他地方，它是解除引用符号，告诉您的代码解决该值。