significado de “referencia” y “desreferencia”

Leí cosas diferentes en Internet y me confundí, porque cada sitio web dice cosas diferentes.

Hablando de C.

Leí acerca de * operador de referencia y operador de desreferenciación; o que hacer referencia significa hacer que un puntero apunte a una variable y desreferenciar está accediendo al valor de la variable a la que apunta el puntero. Entonces me confundí.

¿Puedo obtener una explicación simple pero exhaustiva sobre “referenciar y eliminar referencias”?

Hacer referencia significa tomar la dirección de una variable existente (usando &) para establecer una variable de puntero. Para que sea válido, un puntero debe establecerse en la dirección de una variable del mismo tipo que el puntero, sin el asterisco:

 int c1; int* p1; c1 = 5; p1 = &c1; //p1 references c1 

Desreferenciar un puntero significa usar el operador * (carácter de asterisco) para acceder al valor almacenado en un puntero: NOTA: El valor almacenado en la dirección del puntero debe ser un valor DEL MISMO TIPO que el tipo de variable que el puntero “señala” a, pero no hay garantía de que este sea el caso a menos que el puntero se haya configurado correctamente. El tipo de variable al que apunta el puntero es el tipo menos el asterisco más externo.

 int n1; n1 = *p1; 

La desreferenciación no válida puede o no causar lockings:

  • Cualquier desreferenciación de cualquier puntero no inicializado puede causar un locking
  • La desreferenciación con un molde de tipo no válido tendrá el potencial de causar un locking.
  • La desreferenciación de un puntero a una variable que se asignó dinámicamente y que posteriormente se desasignó puede causar un locking
  • Al hacer referencia a un puntero a una variable que desde entonces se ha salido del scope también puede causar un locking.

Las referencias no válidas tienen más probabilidades de causar errores de comstackción que lockings, pero no es una buena idea confiar en el comstackdor para esto.

Referencias

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. 

Siempre los he escuchado usar en el sentido opuesto:

  • & es el operador de referencia – le da una referencia (puntero) a algún objeto

  • * es el operador de desreferencia – toma una referencia (puntero) y le devuelve el objeto referido;

Para empezar, los tienes al revés: & es referencia y * es la desreferencia.

Hacer referencia a una variable significa acceder a la dirección de memoria de la variable:

 int i = 5; int * p; p = &i; //&i returns the memory address of the variable i. 

Desreferenciar una variable significa acceder a la variable almacenada en una dirección de memoria:

 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 

encuentra la siguiente explicación:

 int main() { int a = 10;// say address of 'a' is 2000; int *p = &a; //it means 'p' is pointing[referencing] to 'a'. ie 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. } 

conclusión:

  1. & [operador de dirección] se usa para hacer referencia.
  2. * [operador de estrella] se utiliza para eliminar referencias.

Referenciando

& es el operador de referencia. Referirá la dirección de memoria a la variable del puntero.

Ejemplo:

 int *p; int a=5; p=&a; // Here Pointer variable p refers to the address of integer variable a. 

Desreferencia

El operador de desreferencia * es utilizado por la variable de puntero para acceder directamente al valor de la variable en lugar de su dirección de memoria.

Ejemplo:

 int *p; int a=5; p=&a; int value=*p; // Value variable will get the value of variable a that pointer variable p pointing to. 

El contexto en el que * está, confunde el significado a veces.

  // 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' } 

Entonces, en el contexto de declarar un tipo como int o char, usaríamos el dereferencer ‘*’ para significar realmente la referencia (la dirección) , lo que lo hace confuso si ve un mensaje de error del comstackdor diciendo: ‘esperando char * ‘que está pidiendo una dirección.

En ese caso, cuando el * está después de un tipo (int, char, etc.), el comstackdor espera la dirección de una variable. Le damos esto usando un operador de referencia, también llamado operador de dirección ‘&’ antes de una variable. Aún más, en el caso que acabo de inventar arriba, el comstackdor espera que la dirección contenga un valor de carácter, no un número. (escriba char * == dirección de un valor que tiene un carácter)

 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; 

Piense en cada variable como si tuviera una posición (o un valor de índice si está familiarizado con las matrices) y un valor. Puede tomar algún tiempo acostumbrarse a pensar en cada variable que tiene dos valores, un valor es su posición, físicamente almacenado con electricidad en su computadora, y un valor que representa la cantidad o letras que el progtwigdor desea almacenar.

 //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. } 

Dentro de cada bloque, copia las variables (si las hay) que se pasan (a través de parámetros dentro de “()” s). Dentro de esos bloques, los cambios a una variable se hacen a una copia de esa variable, la variable usa las mismas letras pero está en una dirección diferente (del original). Al usar la dirección “referencia” del original, podemos cambiar una variable usando un bloque fuera de la principal, o dentro de un elemento secundario de main.