¿Cuál es la diferencia cuando escribo Func1 (int & a) y Func1 (int * a)

Question

Duplicar posibles:
Difference between pointer variable and reference variable in C++

Como estoy empezando con C++ encontré la operación abajo confuso. Tengo que saber sobre pasar por referencia y pasar por valor. Sin embargo, recientemente me encontré con funciones como este que me confunden:

Func1(int &a) 
Func2(int *a) 

Tanto de las funciones esperan que la dirección de una, pero cuando llamo Func1 yo que por Func1(a) y en caso de Func2 llamo por Func2(&a)

¿Cómo es que Func1 está aceptando un int directamente mientras se está a la espera de la dirección de un

Answer 1

al proporcionar un argumento para un parámetro pase por referencia, el compilador hará el & operación necesaria detrás de las escenas. Usted, como programador, sabe que utiliza internamente la dirección de su argumento, pero esto está oculto en la abstracción de paso por referencia. Esto es más seguro que usar un puntero ya que no puede reasignar una referencia inadvertidamente.

Answer 2

Básicamente cuando tiene un & algo que tiene una referencia y esto no es más que un puntero que no puede cambiar en otras palabras un puntero de const básicamente es como * algo, pero en este caso puede cambiar el puntero (a punto en otro lugar) :)

un ejemplo rápido:

Referencia: Object &obj

la misma por escrito con la sintaxis de puntero: Object* const obj

Answer 3

Internamente, no hay mucha diferencia. Pero uno es una referencia, el otro es un puntero. La principal diferencia es que no puede modificar la referencia en su función, por lo que la referencia siempre apuntará al a.

es decir

void func1(int &a) { 
    a = 5; 
} 

Esto modificará a, es decir, el que sea variable de la persona que llama señalaron.

void func2(int *a) { 
    *a = 5; // Same effect as the above code 
    a = &b; // You couldn't do that with a reference 
} 

Answer 4

Func1 tomará una referencia a un int, Func2 tomará un puntero a un int. Cuando ejecuta Func2 (& someint), le está dando a la función la dirección de someint. Esta dirección puede ser desreferenciada para obtener su valor. Cuando "pasa por valor" Func1 (int someint), entonces, se realiza una copia de someint. Cuando pasa por referencia o por puntero, no se realiza dicha copia.

Se puede pensar en una referencia, esencialmente como un "alias" del valor original, o, otra forma de referirse a ella. Sí, es abstracto, pero todo lo demás es específico de la implementación y no debe preocuparse por usted.

Espero que ayude.

Answer 5

Func1(int &a) 
// accepts arguments by reference. 
// changes to a inside Func1 is reflected in the caller 
// a cannot bind to an Rvalue e.g. can't call Func1(5) 
// a can never be referring to something that is not a valid object 

Func2(int *a) 
// accept arguments by value 
// change to a inside Func1 not reflected in caller, changes to *a are 
// a can bind to an Rvalue e.g. Func1(&localvar) 
// a can be NULL. Hence Func2 may need to check if a is NULL 

Answer 6

No es como que,

1. Func1(int &a) - cuando se llama a esta función Func1(a) que pasará el int sólo allí la función recibe la dirección de el paso del argumento.

2. Func2(int *a) - cuando yo llamo a esta función con Func2(&a), esta instrucción solo pasa la referencia de 'a'. En el argumento de la función llamada '*a' que ganará el valor que se refiere al parámetro de la función de llamada '&a'.

Answer 7

En Func1(int &a), &a es la referencia a la variable que se le pasa.

En Func2(int *a), *a es el puntero a la dirección de la variable que va a pasar por su dirección.

Answer 8

cuando la definición de la función es Func1 (int & a), significa que esta función aceptará la dirección de la variable que pasará a esta función como parámetro. (por lo que no es necesario que se ocupe de pasar la dirección de la variable, lo que hará que el parámetro funcione). El comportamiento predeterminado de la función será obtener la dirección de la variable pasada.

por ejemplo

Func1(int &a){ 
    a = 5; //a will store 5 at &a 
} 
Func1(a) // don't need to pass &a, function definition will take care this. 

====================================== =============================

Donde si la definición de la función es Func2 (int * a), significa que lo hará mantener la dirección del valor dado. Esto significa que debe tener que pasar & a en la llamada de función como parámetro, que luego se almacenará como en * a en la definición de función.

por ejemplo

Fun2(int *a){ 
    *a = 7; //a will store 7 at &a 
} 

function call: Fun2(&a); Must have to pass &a, function definition will NOT take care this.