Punteros fantasmas... (asi le puse yo)..

Iniciado por digimikeh, 10 Febrero 2019, 22:43 PM

0 Miembros y 1 Visitante están viendo este tema.

digimikeh

Hola!
Me he topado con el siguiente escenario:

Código (cpp) [Seleccionar]


//En este fragmento al terminar la función, se destruye el contenido de suma y retorna null o vacío, y el puntero suma sigue existiendo en memoria....
int RetornaUnaSuma(int a, int b){

    int * suma = new int;
    *suma = a+b;
    return *suma;
}

//Aqui intento retornar un puntero creado dentro de la misma función...
int * RetornaUnaSuma(int a, int b){

    int * suma = new int;
    *suma = a+b;
    return suma;

    //pero al terminar la función, se destruye el contenido y retorna una dirección de memoria sin contenido, el puntero sigue existiendo..
}



Según yo es mala práctica declarar punteros que quieras retomar dentro de una función o un ámbito...  bueno aparte de mala practica no funciona el retorno...Es como lo pienso?...

Probablemente se pueda devolver punteros cuando éstos mismos ingresan como argumento...

La función sería:

Código (cpp) [Seleccionar]

//Segun yo esto debe funcionar...
int * RetornaUnaSuma(int * pSuma, int a, int b){

    *pSuma = a+b;
    return pSuma;

}



Que opinan...
Saludos.
Dungeons & dragons;
dragons.Attack();

Loretz

Cuando pasas un puntero no constante como parámetro de una función, se sobreentiende que la intención es cambiar el valor de lo apuntado, igual que con las referencias.

En tu caso, la función podría ser:
void RetornaUnaSuma(int* pSuma, int a, int b)
{
    *pSuma = a + b;
}


Donde pSuma se pasa como puntero no constante, y cualquiera que ve su declaración (en un .h por ejemplo), asume que la idea de la función es modificar eso a lo que apunta.

Su uso sería:
int main()
{
    int a = 1;
    int b = 2;
    int* pSuma = new int;

    RetornaUnaSuma(pSuma, a, b);

    std::cout << "*pSuma == " << *pSuma << '\n';

    // y por supuesto:
    delete pSuma;

}


Como ves, que se devuelva un puntero a int no está mal, sólo que no es necesario.

Aunque no puedo dejar de mencionar que en C++ no se usa new / delete, casi nunca.

digimikeh

Entiendo.  Pero es lógico que un puntero al ser creado dentro de una función e intentar devolverlo no sirve de nada?.. eso pienso yo, el puntero queda vacío, sin valor.. y cuando se quiera usar como valor retornado no apuntará a ninguna parte...  es asi?
Dungeons & dragons;
dragons.Attack();

Loretz

Creo que a mediados del sigo XX solía verse funciones que creaban un puntero para ser liberados después, por la función que hacía la llamada. Mira, te pongo un ejemplo:

Citarint* RetornaUnaSuma(int a, int b)
{       

    int * suma = new int; // IMPORTANTE !!! NO OLVIDARSE DE LIBERAR LA MEMORIA CON delete
                          // INSISTO, ES MUY IMPORTANTE, Y NO VAYAIS A USAR free, debe ser delete !!
    *suma = a + b;
    return suma;
}

int main() {
    int a = 1;
    int b = 2;

    int* suma = RetornaUnaSuma(a, b);

    std::cout << "*suma == " << *suma << '\n';

    // ah! y como soy muy aplicado y leo los comentarios de todas las funciones que uso:
    delete suma;
}


digimikeh

Loretz, el codigo que pusiste funciona, entonoces tengo un caos en la cabeza jaja...
Cuando retorna un valor puntero o un valor comun y silvestre no se pierde el valor retornado, entonoces qué pasa con la variable declarada dentro de la funcion?.. no se destruye?...

Lo digo porque, en el caso de retornar un int, supongo que pasaría una copia y no sería problema, pero cuando retornas un int * no estarías retornando una copia... estarias retornando un puntero a la declaracion hecha dentro de la funcion...

Dungeons & dragons;
dragons.Attack();

Loretz

#5
CitarCuando retorna un valor puntero o un valor comun y silvestre no se pierde el valor retornado
?
- Tanto para valores comunes como para punteros: si el valor retornado se lo asignas a alguna variable no se perderá, si no se lo asignas a nadie se perderá.

Citar... entonoces qué pasa con la variable declarada dentro de la funcion?.. no se destruye?...
- Sí, en todos los casos se destruye, no importa qué tipo de variable sea.

Lo que pasa es que las funciones (que devuelven algo), retienen una copia temporal del valor devuelto. Sería estos pasos:
int f() { int i=5; return i; }

  - al llegar a } se hace una copia de i para ser devuelta, y luego muere i.
  - al invocar a f() se dispone (efímeramente) de ese valor temporal devuelto.

(esto no es realmente así porque el C++ exige que los compiladores implementen lo que se llama "return value optimization", pero eso nosotros no lo vemos, es un truco del compilador).

Una variable puntero (un int* o un cosa*) tiene una vida local, como cualquier otra variable, pero la dirección de memoria accedida con new (o malloc, o todos sus parientes), es eterna, se libera con delete (o free) por el programador, o se libera al sistema cuando termina el programa.

Cuando haces:
int j = f();

j en este caso va a tener el valor devuelto por f(), que es ese temporal.

Lo mismo cuando una variable es un puntero, igual.

Si ese temporal devuelto no se lo asignas a nadie, (una variable o una referencia), adiós.

Moraleja: un puntero es una variable más, da lo mismo tener un char que un char*, que un mySuperObjeto*; la diferencia es el tipo de "valor" que se les puede asignar. A una variable se le asigna un valor, un 5, por ejemplo; a un puntero se le asigna una dirección de memoria donde hay un 5. Salvo sutilezas, un puntero es una variable más y se comporta como una.


K-YreX

Cita de: digimikeh en 10 Febrero 2019, 22:43 PM
Hola!
Me he topado con el siguiente escenario:
Código (cpp) [Seleccionar]

//En este fragmento al terminar la función, se destruye el contenido de suma y retorna null o vacío, y el puntero suma sigue existiendo en memoria....
int RetornaUnaSuma(int a, int b){
    int * suma = new int;
    *suma = a+b;
    return *suma;
}
//Aqui intento retornar un puntero creado dentro de la misma función...
int * RetornaUnaSuma(int a, int b){
    int * suma = new int;
    *suma = a+b;
    return suma;
    //pero al terminar la función, se destruye el contenido y retorna una dirección de memoria sin contenido, el puntero sigue existiendo..
}

Según yo es mala práctica declarar punteros que quieras retomar dentro de una función o un ámbito...  bueno aparte de mala practica no funciona el retorno...Es como lo pienso?...
Probablemente se pueda devolver punteros cuando éstos mismos ingresan como argumento...
La función sería:
Código (cpp) [Seleccionar]

//Segun yo esto debe funcionar...
int * RetornaUnaSuma(int * pSuma, int a, int b){
    *pSuma = a+b;
    return pSuma;
}

Que opinan...
Saludos.

Respecto al primer mensaje, te dejo tres variantes para analizar cada una de ellas.
  • Variante 1
    La más simple, una función que suma los parámetros en un entero y lo retorna.
    Código (cpp) [Seleccionar]

    int sumar(int a, int b){
        int suma = a + b;
        return suma;
    }

    En este caso no hay mucha complicación, la variable <suma> que es de ámbito local se destruye al terminar la función.

  • Variante 2
    Usando punteros. Creamos un puntero a entero donde se va a guardar la suma y retornamos el puntero .
    Código (cpp) [Seleccionar]

    int* sumar(int a, int b){
        int *psuma = new int (a + b);
        return psuma;
    }

    En este caso como estamos usando memoria dinámica al usar <new>, tenemos que liberar luego la memoria con <delete>. Como la función retorna el puntero no hay problema porque esa función se tiene que asignar a un puntero a entero en otro sitio (ya sea en el <main> o en otra función). Entonces liberamos la memoria en ese sitio:
    Código (cpp) [Seleccionar]

    int main(){
        int *psuma = sumar(2,2);
        // usas el puntero psuma
        delete psuma;
    }


  • Variante 3
    Esto es lo que has implementado en primer lugar y la opción más rara y menos apropiada. Crear un putero a entero donde guardar la suma y retornar el valor de la suma .
    Código (cpp) [Seleccionar]

    int sumar(int a, int b){
        int *psuma = new int (a + b);
        return *psuma;
    }

    En este caso tenemos un problema con la memoria dinámica. Una de las cosas que tiene la memoria dinámica es que cuando se crea un objeto/variable usando esta, el objeto/variable siempre debe estar apuntado por algún puntero. Si deja de ser apuntado por alguien, se pierde. Entonces aquí cuando acaba la función retorna el valor de la suma, el cual es correcto, pero se pierde el puntero <psuma> por lo que ya no se puede liberar.
    Código (cpp) [Seleccionar]

    int main(){
        int suma = sumar(2,2);
        // usamos la variable suma pero...
        // hemos perdido el puntero local de la funcion
    }



    Si quieres profundizar un poco el tema de los valores de retorno, que se guarde temporalmente el valor que se devuelve antes de ser destruido puedes indagar un poco dentro del lenguaje ensamblador. Puedes ver una llamada a función sencilla como esta para ver como la función guarda en un registro el valor de retorno. Entonces cuando la función ha acabado, el valor de retorno está guardado en un registro que debe ser guardado en otro sitio antes de volver a usar ese registro, por eso hay que asignarlo a una variable. Suerte :-X
Código (cpp) [Seleccionar]

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

digimikeh

Gracias por las respuestas a ambos.. me ha quedado mucho mas claro ahora con lo ultimo que han dicho..

Una ultima duda:

Código (cpp) [Seleccionar]


int * sumar(int a, int b){
    int * psuma = new int;
    *psuma = a + b;
    return psuma;

}

int main (){
    int a = 5;
    int b = 10;

    int * psuma = new int;    //duda con el nombre psuma
    psuma = sumar(a, b);
   
    delete psuma;                //aqui se elimina psuma, pero cual?, el declarado
                                        //en main solamente o los dos?

}



Que pasa en el siguiente caso ?

Código (cpp) [Seleccionar]


int * sumar(int a, int b){
    int * psuma = new int;
    *psuma = a + b;
    return psuma;

}

int main (){
    int a = 5;
    int b = 10;

    int * punteroSuma = new int;    //modificado el nombre
    punteroSuma = sumar(a, b);
   
    delete punteroSuma;      //aqui se elimina psuma, punteroSuma o ambos?
}




Gracias!
Dungeons & dragons;
dragons.Attack();

K-YreX

Se eliminan ambos y ahora te explico.
Cuando se elimina un puntero, no eliminas el puntero como tal, sino que liberas la memoria a la que apunta el puntero. Cuando asignas un puntero a otro, ambos apuntan a la misma dirección de memoria. Entonces con eliminar uno de los dos, ya queda liberada la memoria.

Código (cpp) [Seleccionar]

int* sumar(int a, int b){
    int *suma = new int(a+b); // reservas memoria para un entero
    return suma;
}

int main(){
    int *psuma = sumar(2,2); // psuma apunta a la misma memoria que apuntaba suma
    delete psuma; // liberamos la memoria a la que apunta psuma que es la misma que suma
}
Código (cpp) [Seleccionar]

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

digimikeh

entiendo, entiendo...

tengo que imaginar al delete como un interruptor que desactiva el espacio de memoria
y al new como que lo activa..  podría ser así la abstracción.

Gracias nuevamente!! : :o :)
Dungeons & dragons;
dragons.Attack();