Mil*_*iez 56 c pointers reference dereference
我在互联网上阅读不同的东西并感到困惑,因为每个网站都说不同的东西.
谈到C.
我读到了*引用运算符&和解引用运算符; 或者引用意味着使指针指向变量,并且解除引用正在访问指针指向的变量的值.所以我很困惑.
我是否可以获得有关"引用和取消引用"的简单但彻底的解释？
A B*_*A B 80
引用意味着获取现有变量的地址(使用&)来设置指针变量.为了有效,必须将指针设置为与指针相同类型的变量的地址,而不是星号:
int c1;
int* p1;
c1 = 5;
p1 = &c1;
//p1 references c1
取消引用指针意味着使用*运算符(星号字符)来访问存储在指针中的值:注意:存储在指针地址处的值必须是值相同类型作为指针"指向"的变量类型to,但除非指针设置正确,否则无法保证是这种情况.指针指向的变量类型是最外面的星号.
int n1;
n1 = *p1;
无效的解除引用可能会导致崩溃,也可能不会导致崩溃:
无效引用更可能导致编译器错误而不是崩溃,但依赖编译器并不是一个好主意.
参考文献:
http://www.codingunit.com/cplusplus-tutorial-pointers-reference-and-dereference-operators
& is the reference operator and can be read as “address of”.
* is the dereference operator and can be read as “value pointed by”.
http://www.cplusplus.com/doc/tutorial/pointers/
& is the reference operator
* is the dereference operator
http://en.wikipedia.org/wiki/Dereference_operator
The dereference operator * is also called the indirection operator.
App*_*ish 11
首先,你有他们倒退:&是参考,*是解除引用.
引用变量意味着访问变量的内存地址:
int i = 5;
int * p;
p = &i; //&i returns the memory address of the variable i.
取消引用变量意味着访问存储在存储器地址的变量:
int i = 5;
int * p;
p = &i;
*p = 7; //*p returns the variable stored at the memory address stored in p, which is i.
//i is now 7
找到以下解释:
int main()
{
int a = 10;// say address of 'a' is 2000;
int *p = &a; //it means 'p' is pointing[referencing] to 'a'. i.e p->2000
int c = *p; //*p means dereferncing. it will give the content of the address pointed by 'p'. in this case 'p' is pointing to 2000[address of 'a' variable], content of 2000 is 10. so *p will give 10.
}
结论:
& [地址运算符]用于引用.* [star operator]用于取消引用.* 所在的上下文，有时会混淆意思。
// when declaring a function
int function(int*); // This function is being declared as a function that takes in an 'address' that holds a number (so int*), it's asking for a 'reference', interchangeably called 'address'. When I 'call'(use) this function later, I better give it a variable-address! So instead of var, or q, or w, or p, I give it the address of var so &var, or &q, or &w, or &p.
//even though the symbol ' * ' is typically used to mean 'dereferenced variable'(meaning: to use the value at the address of a variable)--despite it's common use, in this case, the symbol means a 'reference', again, in THIS context. (context here being the declaration of a 'prototype'.)
//when calling a function
int main(){
function(&var); // we are giving the function a 'reference', we are giving it an 'address'
}
所以，在的情况下，宣布一个类型，如int或字符，我们将使用dereferencer “*”实际上是指参考（地址），这使得它混乱，如果你看到来自编译器说的错误消息：“期待char*' 要求一个地址。
在这种情况下，当 * 在类型（int、char 等）之后时，编译器需要一个变量的地址。我们通过使用引用运算符来实现这一点，也称为变量前的地址运算符“&”。更进一步，在我刚刚在上面编写的情况下，编译器期望地址保存一个字符值，而不是一个数字。（键入 char * == 具有字符的值的地址）
int* p;
int *a; // both are 'pointer' declarations. We are telling the compiler that we will soon give these variables an address (with &).
int c = 10; //declare and initialize a random variable
//assign the variable to a pointer, we do this so that we can modify the value of c from a different function regardless of the scope of that function (elaboration in a second)
p = c; //ERROR, we assigned a 'value' to this 'pointer'. We need to assign an 'address', a 'reference'.
p = &c; // instead of a value such as: 'q',5,'t', or 2.1 we gave the pointer an 'address', which we could actually print with printf(), and would be something like
//so
p = 0xab33d111; //the address of c, (not specifically this value for the address, it'll look like this though, with the 0x in the beggining, the computer treats these different from regular numbers)
*p = 10; // the value of c
a = &c; // I can still give c another pointer, even though it already has the pointer variable "p"
*a = 10;
a = 0xab33d111;
将每个变量视为具有位置（或索引值，如果您熟悉数组）和值。可能需要一些时间来适应每个变量都有两个值，一个值是它的位置，物理存储在计算机中，一个值代表程序员想要存储的任何数量或字母。
//Why it's used
int function(b){
b = b + 1; // we just want to add one to any variable that this function operates on.
}
int main(){
int c = 1; // I want this variable to be 3.
function(c);
function(c);// I call the function I made above twice, because I want c to be 3.
// this will return c as 1. Even though I called it twice.
// when you call a function it makes a copy of the variable.
// so the function that I call "function", made a copy of c, and that function is only changing the "copy" of c, so it doesn't affect the original
}
//let's redo this whole thing, and use pointers
int function(int* b){ // this time, the function is 'asking' (won't run without) for a variable that 'points' to a number-value (int). So it wants an integer pointer--an address that holds a number.
*b = *b + 1; //grab the value of the address, and add one to the value stored at that address
}
int main(){
int c = 1; //again, I want this to be three at the end of the program
int *p = &c; // on the left, I'm declaring a pointer, I'm telling the compiler that I'm about to have this letter point to an certain spot in my computer. Immediately after I used the assignment operator (the ' = ') to assign the address of c to this variable (pointer in this case) p. I do this using the address-of operator (referencer)' & '.
function(p); // not *p, because that will dereference. which would give an integer, not an integer pointer ( function wants a reference to an int called int*, we aren't going to use *p because that will give the function an int instead of an address that stores an int.
function(&c); // this is giving the same thing as above, p = the address of c, so we can pass the 'pointer' or we can pass the 'address' that the pointer(variable) is 'pointing','referencing' to. Which is &c. 0xaabbcc1122...
//now, the function is making a copy of c's address, but it doesn't matter if it's a copy or not, because it's going to point the computer to the exact same spot (hence, The Address), and it will be changed for main's version of c as well.
}
在每个块内，它复制传入的变量（如果有）（通过“()”中的参数）。在这些块中，对变量的更改是对该变量的副本进行的，该变量使用相同的字母但位于不同的地址（与原始地址不同）。通过使用原始地址“引用”，我们可以使用 main 外部的块或 main 的子代内部的块来更改变量。