elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Rompecabezas de Bitcoin, Medio millón USD en premios


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Uso de referencias con memoria dinámica [C++]
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Uso de referencias con memoria dinámica [C++]  (Leído 1,177 veces)
K-YreX
Moderador
***
Desconectado Desconectado

Mensajes: 904



Ver Perfil
Uso de referencias con memoria dinámica [C++]
« en: 30 Marzo 2019, 14:23 pm »

Cuando trabajamos con memoria dinámica y pasamos una variable (ya sea un array, una variable sencilla o un objeto), hasta el punto que yo sé, lo que estamos pasando es el puntero que apunta a la dirección de memoria donde hemos guardado esa variable. Entonces me surgen las siguientes preguntas:
  • ¿Por qué si pasamos un puntero a una función y queremos reservar memoria una vez en la función, hay que pasar ese puntero además por referencia?
  • Tenemos, imaginemos, un array bidimensional (matriz) que ha sido reservada con memoria dinámica, ¿hay diferencia entre pasarla por referencia o por valor?
En ambos casos estamos pasando la dirección de memoria de su primer elemento, pero viendo que para la primera pregunta que he planteado sí hay diferencia entre usar referencias o no, quería saber si para este segundo caso es más "eficiente" pasarla por referencia.


« Última modificación: 31 Marzo 2019, 13:58 pm por YreX-DwX » En línea

Código
  1. cout << "Todos tenemos un defecto, un error en nuestro código" << endl;
CalgaryCorpus


Desconectado Desconectado

Mensajes: 323


Ver Perfil WWW
Re: Uso de referencias con memoria dinámica [C++]
« Respuesta #1 en: 30 Marzo 2019, 15:42 pm »

Si pasas por valor, no lograras que lo que asignes a ese puntero se modifique, pues vas a estar asignandole a una copia.

No hay diferencia de otra manera.


En línea

Aqui mi perfil en LinkedIn, invitame un cafe aqui
K-YreX
Moderador
***
Desconectado Desconectado

Mensajes: 904



Ver Perfil
Re: Uso de referencias con memoria dinámica [C++]
« Respuesta #2 en: 30 Marzo 2019, 18:44 pm »

Después de darle unas cuántas vueltas creo que he llegado a una explicación. Si alguien ve algo raro o incorrecto que me lo comente para corregirlo ya que creo que puede servir para gente que tenga dudas con esto :-X
Voy a usar un ejemplo muy sencillo para explicar esto:
Código
  1. void anular(int *v, int pos){
  2.    v[pos] = 0;
  3. }
  4.  
  5. int main(){
  6.    int *p;
  7.    p = new int [2];
  8.    p[0] = 1;
  9.    p[1] = 2;
  10.    anular(p,1);
  11. }

En la línea 6, declaramos un puntero (almacena una dirección de memoria) <p> y hacemos que apunte a <NULL>. Vamos a suponer que se guarda en la posición de memoria 0x1 (voy a usar posiciones de memoria consecutivas para simplificar el ejemplo). Entonces quedaría así:
Código:
0x1(p) = NULL

En la línea 7, reservamos memoria para guardar dos enteros. Suponemos que sus posiciones son 0x2 y 0x3 respectivamente y en las líneas 8 y 9 asignamos valores a esas posiciones. Entonces tenemos:
Código:
0x1(p) = 0x2
0x2(p[0]) = 1
0x3(p[1]) = 2

En la línea 10, llamamos a la función <anular()>, la cual recibe el puntero que almacena la dirección de memoria del primer elemento del array. Al ser pasado por valor, se copia el contenido de <p> en <v> (suponemos <v> en 0x4) y el 1 se copia en <pos> (suponemos 0x5). Entonces tenemos antes de ejecutar la función:
Código:
0x1(p) = 0x2
0x2(p[0]) = 1
0x3(p[1]) = 2
0x4(v) = 0x2
0x5(pos) = 1

Al ejecutar la línea 2, el contenido se modifica en el "array original" (que es siempre el mismo porque sólo tenemos uno). Esto es porque <v> almacena la misma posición de memoria que <p> (OJO: <v> no almacena la posición de memoria dónde se guarda <p>, sino la dirección de memoria que se guarda EN <p>).
Por eso para hacer cambios o acciones sobre el array en sí, no es necesario pasarlo por referencia, porque ambos punteros apuntan al mismo sitio.

Sin embargo, si tenemos esta alternativa:
Código
  1. void reservar(int *&v, int size){
  2.    v = new int [size];
  3. }
Y queremos reservar memoria, esto es una operación que se debe aplicar, siguiendo con el mismo ejemplo, sobre 0x1 (dirección en la que hemos guardado <p>), no sobre 0x4 (dirección en la que hemos guardado <v>). Al pasar por referencia la tabla de direcciones de memoria anterior quedaría de la siguiente manera:
Código:
0x1(p) = 0x2
0x2(p[0]) = 1
0x3(p[1]) = 2
0x1(v) = 0x2 (no hemos copiado el valor de <p> en otra direccion de memoria sino que usamos la direccion de memoria de <p>
0x5(pos) = 1
Y entonces ahora sí que podemos aplicar la orden de reserva sobre <v> ya que en realidad la estamos aplicando sobre <p> (realmente se lo estamos aplicando a la dirección 0x1).

Entonces mi conclusión es que el paso por referencia es para operar sobre la dirección de memoria DÓNDE está el puntero, no para operar sobre la dirección de memoria que está EN el puntero. Por lo que supongo que a efectos de "eficiencia", es lo mismo hacer un paso por referencia que por valor (en ambos casos pasamos únicamente una dirección de memoria, en un caso la dirección dónde está el puntero y en el otro, la dirección que guarda el puntero)


Espero que le sirva a alguien. :-X
« Última modificación: 30 Marzo 2019, 19:57 pm por YreX-DwX » En línea

Código
  1. cout << "Todos tenemos un defecto, un error en nuestro código" << endl;
Loretz

Desconectado Desconectado

Mensajes: 112


Ver Perfil
Re: Uso de referencias con memoria dinámica [C++]
« Respuesta #3 en: 31 Marzo 2019, 01:20 am »

Creo que no está del todo bien.

Pongo acá tu ejemplo añadiendo algunos textos que pueden ayudar:

Código
  1. #include <iostream>
  2.  
  3. void anular(int* v, int pos)
  4. {
  5.    std::cout << "la direccion de v es: " << &v << " pero apunta a " << v << " (igual que p)\n";
  6.    v[pos] = 0;
  7. }
  8.  
  9. int main()
  10. {
  11.    int* p; // sin inicializar. no es NULL
  12.    // std::cout << p << '\n'; [[error -> no puede accederse a un puntero sin inicializar]]
  13.    std::cout << "p es una variable que esta en algun lado, su direccion es: " << &p << '\n';
  14.  
  15.    p = nullptr; // se la asigna a p el valor cero (cero de puntero, nullptr no es la macro NULL, es de tipo nullptr_t).
  16.    std::cout << "p apunta a: " << p << '\n';
  17.  
  18.  
  19.    p = new int[2];
  20.    std::cout << "Ahora p apunta a: " << p << '\n';
  21.    std::cout << "pero su direccion sigue siendo: " << &p << '\n';
  22.  
  23.    p[0] = 1;
  24.    p[1] = 2;
  25.  
  26.    anular(p, 1);
  27.  
  28. }

Yo lo diría así:
Un puntero es una variable como cualquier otra, en este caso, p es de tipo int*. Como toda variable está en algún lado, se puede tomar su dirección; además se le puede asignar un valor, otra dirección de memoria, aunque esa dirección de memoria que se asigna al puntero puede estar en el free store (memoria libre) o en la pila (stack), a p le da igual. Por ejemplo:
Código:
int i=5; p = &i; // stack

En tu línea 6 tienes declarado el puntero p, pero sin inicializar, no apunta a NULL; probablemente apunte a algo pero no podemos saberlo, intentar acceder a qué apunta un puntero sin inicializar es un error que no debería siquiera compilar. Lo que sí puedes es leer su propia dirección, en dónde está. Entonces, en un puntero tenemos su propia dirección de memoria y la dirección de memoria a la que apunta.

Cuando pasas a p como parámetro de anular(), puedes ver que la dirección de v es diferente a la dirección de p, naturalmente, v está en el el stack frame de anular(), pero apunta a la misma dirección que apunta p. Puedes verlo ejecutando mi ejemplo.

Si observas los valores reales de las direcciones de memoria a donde apuntan p[0] y p[1] podrás ver que
1) p == &p[0];
2) &p[1] == &p[0] + sizeof(int*);

p y &p[0] podrían llegar a ser de tipos distintos, pero los dos guardan la misma dirección de memoria.

Como &p[0] y &p[1] son las direcciones consecutivas en memoria capaces de guardar sendos int(s), deben diferir en sizof(int*), ni más ni menos.
En línea

NextByte

Desconectado Desconectado

Mensajes: 24


Ver Perfil
Re: Uso de referencias con memoria dinámica [C++]
« Respuesta #4 en: 31 Marzo 2019, 05:01 am »

Creo que no está del todo bien.

Pongo acá tu ejemplo añadiendo algunos textos que pueden ayudar:

Código
  1. #include <iostream>
  2.  
  3. void anular(int* v, int pos)
  4. {
  5.    std::cout << "la direccion de v es: " << &v << " pero apunta a " << v << " (igual que p)\n";
  6.    v[pos] = 0;
  7. }
  8.  
  9. int main()
  10. {
  11.    int* p; // sin inicializar. no es NULL
  12.    // std::cout << p << '\n'; [[error -> no puede accederse a un puntero sin inicializar]]
  13.    std::cout << "p es una variable que esta en algun lado, su direccion es: " << &p << '\n';
  14.  
  15.    p = nullptr; // se la asigna a p el valor cero (cero de puntero, nullptr no es la macro NULL, es de tipo nullptr_t).
  16.    std::cout << "p apunta a: " << p << '\n';
  17.  
  18.  
  19.    p = new int[2];
  20.    std::cout << "Ahora p apunta a: " << p << '\n';
  21.    std::cout << "pero su direccion sigue siendo: " << &p << '\n';
  22.  
  23.    p[0] = 1;
  24.    p[1] = 2;
  25.  
  26.    anular(p, 1);
  27.  
  28. }

Yo lo diría así:
Un puntero es una variable como cualquier otra, en este caso, p es de tipo int*. Como toda variable está en algún lado, se puede tomar su dirección; además se le puede asignar un valor, otra dirección de memoria, aunque esa dirección de memoria que se asigna al puntero puede estar en el free store (memoria libre) o en la pila (stack), a p le da igual. Por ejemplo:
Código:
int i=5; p = &i; // stack

En tu línea 6 tienes declarado el puntero p, pero sin inicializar, no apunta a NULL; probablemente apunte a algo pero no podemos saberlo, intentar acceder a qué apunta un puntero sin inicializar es un error que no debería siquiera compilar. Lo que sí puedes es leer su propia dirección, en dónde está. Entonces, en un puntero tenemos su propia dirección de memoria y la dirección de memoria a la que apunta.

Cuando pasas a p como parámetro de anular(), puedes ver que la dirección de v es diferente a la dirección de p, naturalmente, v está en el el stack frame de anular(), pero apunta a la misma dirección que apunta p. Puedes verlo ejecutando mi ejemplo.

Si observas los valores reales de las direcciones de memoria a donde apuntan p[0] y p[1] podrás ver que
1) p == &p[0];
2) &p[1] == &p[0] + sizeof(int*);

p y &p[0] podrían llegar a ser de tipos distintos, pero los dos guardan la misma dirección de memoria.

Como &p[0] y &p[1] son las direcciones consecutivas en memoria capaces de guardar sendos int(s), deben diferir en sizof(int*), ni más ni menos.



¿ Por qué se dice que la macro NULL no es recomendada en C++ ?, he visto varias fuentes que afirman eso pero no logro entender el por que. Sé que la macro 'NULL' viene desde C y que representa el numero entero 0 y que 'nullptr' fue agregado en C++11 pero ¿ qué problemas puede conllevar el usar la macro 'NULL'. ?
« Última modificación: 31 Marzo 2019, 05:04 am por NextByte » En línea

K-YreX
Moderador
***
Desconectado Desconectado

Mensajes: 904



Ver Perfil
Re: Uso de referencias con memoria dinámica [C++]
« Respuesta #5 en: 31 Marzo 2019, 13:47 pm »

En tu línea 6 tienes declarado el puntero p, pero sin inicializar, no apunta a NULL
Tienes razón en esto. Fue fallo mío que pensé en asignarle NULL pero lo olvidé al estar pensando en el resto de la explicación :xD
Además no conocía la diferencia entre <NULL> y <nullptr> así que gracias también por ello.

¿ Por qué se dice que la macro NULL no es recomendada en C++ ?, he visto varias fuentes que afirman eso pero no logro entender el por que. Sé que la macro 'NULL' viene desde C y que representa el numero entero 0 y que 'nullptr' fue agregado en C++11 pero ¿ qué problemas puede conllevar el usar la macro 'NULL'. ?
Por lo que he leído yo es porque <NULL> equivale a un 0 de tipo <int>; mientras que <nullptr> equivale a 0 también (si muestras el valor puedes verlo) siempre sigue siendo de tipo puntero, como dice @Loretz es de tipo <nullptr_t>. Entonces se evita el uso de <NULL> porque puede dar errores de ambigüedad al cambiar el tipo de dato.

Como &p[0] y &p[1] son las direcciones consecutivas en memoria capaces de guardar sendos int(s), deben diferir en sizof(int*), ni más ni menos.
Es cierto que sus posiciones de memoria deben diferir en el tamaño del tipo de dato que puede almacenar. Pero como comenté, uso posiciones de memoria consecutivas y simples ya que lo que quería que se entendiese era ver de qué posiciones de memoria estamos hablando en cada momento.

Gracias por la respuesta ya que me diste la idea de probar el mismo programa para ver las posiciones de memoria que se utilizan. He añadido otra función para que se vea mejor el paso de un puntero por valor y por referencia.
Código
  1. int main(){
  2. int *p = nullptr;
  3. cout << "p esta en " << &p << " y su contenido es " << p << endl;
  4. reservarMemoria(p,2);
  5. p[0] = 1;
  6. cout << "p[0] esta en " << &p[0] << " y su contenido es " << p[0] << endl;
  7. p[1] = 2;
  8. cout << "p[1] esta en " << &p[1] << " y su contenido es " << p[1] << endl;
  9. anular(p,1);
  10. // cout << "p[1] esta en " << &p[1] << " y su contenido es " << p[1] << endl;
  11. }
  12.  
  13. void reservarMemoria(int *&v, int size){
  14. cout << "FUNCION RESERVAR MEMORIA (puntero por referencia)" << endl;
  15. cout << "v esta en " << &v << " y su contenido es " << v << endl;
  16. v = new int [size];
  17. }
  18.  
  19. void anular(int *v, int pos){
  20. cout << "FUNCION ANULAR (puntero por valor)" << endl;
  21. cout << "v esta en " << &v << " y su contenido es " << v << endl;
  22. v[pos] = 0;
  23. }

Al ejecutarlo obtenemos la siguiente salida (las posiciones de memoria depende de cada ejecución) donde podemos observar que coinciden los valores que comenté en mi anteior explicación:
Código:
p esta en 0x7fff4ce5ed50 y su contenido es 0
FUNCION RESERVAR MEMORIA (puntero por referencia)
v esta en 0x7fff4ce5ed50 y su contenido es 0
p[0] esta en 0x5650660fe280 y su contenido es 1
p[1] esta en 0x5650660fe284 y su contenido es 2
FUNCION ANULAR (puntero por valor)
v esta en 0x7fff4ce5ed38 y su contenido es 0x5650660fe280
En la función <reservarMemoria()> como se pasa el puntero por referencia se ve que la dirección de memoria de <v> (&v) es la misma que la de <p> (&p). Sin embargo en la función <anular()> como se pasa el puntero por valor, la dirección de memoria de <v> (&v) es distinta  a la de <p> (&p) aunque el valor que guardan que es la dirección de memoria de <p[0]> (&p[0]) en ambos casos, sí es la misma.
« Última modificación: 31 Marzo 2019, 13:58 pm por YreX-DwX » En línea

Código
  1. cout << "Todos tenemos un defecto, un error en nuestro código" << endl;
Loretz

Desconectado Desconectado

Mensajes: 112


Ver Perfil
Re: Uso de referencias con memoria dinámica [C++]
« Respuesta #6 en: 1 Abril 2019, 02:40 am »

Citar
¿ Por qué se dice que la macro NULL no es recomendada en C++ ?

Acá va un ejemplo donde se invocan distintas funciones sobrecargadas:
 
Código:
#include <iostream>

void fun(int i)
{
    std::cout << "int 0\n";
}

void fun(int* p)
{
    std::cout << "puntero nulo\n";
}

int main()
{
    fun(0);       // no hay duda de cuál de las dos se invoca.
    fun(nullptr); // tampoco hay duda
    fun(NULL);    // ¿y ahora?
}


Además la constante nullptr (de tipo nullptr_t):

- Puede convertirse a cualquier tipo de puntero o puntero a miembro y a bool, pero a nada más.
- No puede ser usada en expresiones aritméticas.
- Puede comparase con el int 0 [[ como en if(p == 0) ]]
- Puede usarse en expresiones relacionales (expresiones que se evalúan a true o false) para compararse con punteros (u otro dato de tipo nullptr_t).

De todos modos, por una cuestión de compatibilidad, aún en C++17 es aceptable asignar 0 (o NULL) a un puntero, como en
Código:
char* pch = 0;
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Memoria dinámica
Programación C/C++
eleon 6 3,641 Último mensaje 24 Enero 2012, 22:17 pm
por Eternal Idol
Memoria dinamica? « 1 2 »
Programación C/C++
vangodp 11 3,244 Último mensaje 30 Abril 2014, 12:35 pm
por vangodp
Memoría dinámica
Programación C/C++
Developer Diego 4 1,374 Último mensaje 20 Mayo 2014, 23:10 pm
por Developer Diego
Problemas de perdida de memoria con memoria dinamica
Programación C/C++
ing_maipu 1 1,173 Último mensaje 28 Octubre 2017, 18:48 pm
por CalgaryCorpus
C++ Memoria dinámica
Programación C/C++
rafaelfinacut10 2 1,511 Último mensaje 12 Febrero 2018, 16:18 pm
por dijsktra
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines