Problemas con funcion recursiva

[Ricardo]

Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?

personal web site:
http://www.geocities.com/ricardo_rios_sv/index.html

[Pascal Bourguignon]

Post by Ricardo
Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?

Jamas explicitamente. ¡Usa un basurero!

http://www.hpl.hp.com/personal/Hans_Boehm/gc/

[Pedro Maicas]

Post by Ricardo
Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?

Interesante cuestion, yo añadiría otras preguntas
que a mi me corroen desde hace tiempo ¿cuando debo
asignar memoria a un arreglo ? ¿Cuando debo usar
el operador + ? ¿ a que huele el postincremento ?


Saludos :-) -Pedro-

http://www.maicas.net/

e-mail en www.maicas.net

[Bartomeu]

La norma que recomiendo, es liberarla en el mismo nivel en que se asigna.

entrada funcion recursiva
asingnar memoria A
hacer cosas, entre ellas las llamadas recursivas necesarias
liberar memoria A
salir de la recursion

Post by Ricardo
Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?
http://www.geocities.com/ricardo_rios_sv/index.html

[Zephryn Xirdal]

Si la memoria no te sirve ya en la llamada recursiva, puedes liberarla a la
entrada de ésta excepto la primera vez, ahorrarás enormes cantidades de ella
y mejorarás el rendimiento, amén de evitar fragmentación, pues si el bloque
alojado de nuevo tiene el mismo tamaño o menos, se reutilizará el mismo
bloque:

char *p;

bool recursivo(bool primero)
{
if(!primero)
delete p;

p=new tal
recursivo(false);
}

etc.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
La norma que recomiendo, es liberarla en el mismo nivel en que se asigna.
entrada funcion recursiva
asingnar memoria A
hacer cosas, entre ellas las llamadas recursivas necesarias
liberar memoria A
salir de la recursion

Post by Ricardo
Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?
http://www.geocities.com/ricardo_rios_sv/index.html

[Bartomeu]

Si siempre utilizas la misma memoria es mejor hacer la asignación y
liberación fuera de la recursividad, en el mismo nivel, y no complicar la
función recursiva, ya suelen ser lo suficiente complicadas con la detección
del fin de la recursividad:

tipo *p;

// no se puede llamar directamente a esta función
void Recursiva (void) {
// hacer lo que necesites
Recursiva();
// hacer más cosas necesarias
}

// para llamar a la función anterior usar esta llamada
void Entrada_a_la_funcion_recursiva(void) {
p = new tipo;
Recursiva();
delete p;
}

Si cada recursividad necesita su memoria particular el caso sería:

void Recursiva(void) {
tipo *p = new tipo;
// hacer lo que necesites
Recursiva();
// hacer más cosas necesarias
delete p;
}

Post by Zephryn Xirdal
Si la memoria no te sirve ya en la llamada recursiva, puedes liberarla a
la entrada de ésta excepto la primera vez, ahorrarás enormes cantidades de
ella y mejorarás el rendimiento, amén de evitar fragmentación, pues si el
bloque alojado de nuevo tiene el mismo tamaño o menos, se reutilizará el
char *p;
bool recursivo(bool primero)
{
if(!primero)
delete p;
p=new tal
recursivo(false);
}
etc.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
La norma que recomiendo, es liberarla en el mismo nivel en que se asigna.
entrada funcion recursiva
asingnar memoria A
hacer cosas, entre ellas las llamadas recursivas necesarias
liberar memoria A
salir de la recursion

Post by Ricardo
Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?
http://www.geocities.com/ricardo_rios_sv/index.html

[Bartomeu]

Me he mirado tu código con más atención y tiene un fallo, debido a que cada
nivel no limpia sus cosas.

Suponiendo que realmente quieres utilizar cada vez una memoria diferente
apuntada por el mismo puntero, vigilas correctamente la primera llamada para
no hacer un delete sin sentido, pero te olvidas de hacer un delete despues
de la última salida. Cuando se acaba la recursividad 'p' apunta a algo, que
no has borrado. Es el problema cuando un nivel tiene que hacer delete de un
new de otro nivel. Es recomendable que cada new tenga su delete en el mismo
nivel.

Post by Zephryn Xirdal
Si la memoria no te sirve ya en la llamada recursiva, puedes liberarla a
la entrada de ésta excepto la primera vez, ahorrarás enormes cantidades de
ella y mejorarás el rendimiento, amén de evitar fragmentación, pues si el
bloque alojado de nuevo tiene el mismo tamaño o menos, se reutilizará el
char *p;
bool recursivo(bool primero)
{
if(!primero)
delete p;
p=new tal
recursivo(false);
}
etc.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
La norma que recomiendo, es liberarla en el mismo nivel en que se asigna.
entrada funcion recursiva
asingnar memoria A
hacer cosas, entre ellas las llamadas recursivas necesarias
liberar memoria A
salir de la recursion

Post by Ricardo
Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?
http://www.geocities.com/ricardo_rios_sv/index.html

[Zephryn Xirdal]

Coñe, simplemente era una indicación. Claro que no libera al final, ni
existe condición de salida, por lo que el código terminará colapsando el
ordenador...

Respecto a tu post anterior, si conoces el tamaño máximo de la memoria,
evidentemente, es mejor, pero si no, te toca hacerlo de una de las dos otras
formas.

Yo sigo pensando que es mejor la mía. Imagina que en cada llamada vas a
asignar un bloque de 1Kb. Eso en cualquier arquitectura de PC significa que
el bloque devuelto va a ser de 4K, por lo que vamos a tomar este valor.
Veamos cómo crece el consumo de RAM respecto a la cantidad de llamadas
recursivas:

10 -> 40K
100 -> 400K
1 000-> 4M
10.000 -> 40M
100.000 -> 400M

Con la opción que yo digo, el máximo sería 8K, aparte del ahorro en la
fragmentación de la memoria.

Creo que vale la pena complicarse un poco la vida y ahorrar esa cantidad de
memoria. Aunque el algoritmo no sea "políticamente correcto", es mucho más
eficaz.

Imagina que en lugar de 1K fueran 10K, o 10K. Imagina que ejecutas en una
PDA, o en una placa con 64K.

Aparte, tu algoritmo podría calcular 100 números primos (por ejemplo) antes
de agotar la memoria mientras que el mío podría calcular tantos como diera
el tamaño de la pila de llamadas.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
Me he mirado tu código con más atención y tiene un fallo, debido a que
cada nivel no limpia sus cosas.
Suponiendo que realmente quieres utilizar cada vez una memoria diferente
apuntada por el mismo puntero, vigilas correctamente la primera llamada
para no hacer un delete sin sentido, pero te olvidas de hacer un delete
despues de la última salida. Cuando se acaba la recursividad 'p' apunta a
algo, que no has borrado. Es el problema cuando un nivel tiene que hacer
delete de un new de otro nivel. Es recomendable que cada new tenga su
delete en el mismo nivel.

Post by Zephryn Xirdal
Si la memoria no te sirve ya en la llamada recursiva, puedes liberarla a
la entrada de ésta excepto la primera vez, ahorrarás enormes cantidades
de ella y mejorarás el rendimiento, amén de evitar fragmentación, pues si
el bloque alojado de nuevo tiene el mismo tamaño o menos, se reutilizará
char *p;
bool recursivo(bool primero)
{
if(!primero)
delete p;
p=new tal
recursivo(false);
}
etc.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
La norma que recomiendo, es liberarla en el mismo nivel en que se asigna.
entrada funcion recursiva
asingnar memoria A
hacer cosas, entre ellas las llamadas recursivas necesarias
liberar memoria A
salir de la recursion

Post by Ricardo
Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?
http://www.geocities.com/ricardo_rios_sv/index.html

[Bartomeu]

Yo nunca he tenido que volver a trabajar con placas pequeñas, desde que dejé
el Z80, gracias a Dios. Y, francamente, espero no tener que meterme en PDA.
;-)

Y dado que el que inició el hilo, no ha puesto ningún ejemplo de lo que
pretendía hacer y no le salía, no creo que podamos ayudarle más.

De todas maneras soy de la opinión personal que si tienes una función
recursiva que te tiene que trabajar a más de 10-15 niveles la debes usar
para testear una función iterativa que sea la que realmente haga el trabajo
en el programa final. Siempre será más eficiente.

P.D.: Te he mandado un mensaje ajeno a este hilo a gmail

Post by Zephryn Xirdal
Coñe, simplemente era una indicación. Claro que no libera al final, ni
existe condición de salida, por lo que el código terminará colapsando el
ordenador...
Respecto a tu post anterior, si conoces el tamaño máximo de la memoria,
evidentemente, es mejor, pero si no, te toca hacerlo de una de las dos
otras formas.
Yo sigo pensando que es mejor la mía. Imagina que en cada llamada vas a
asignar un bloque de 1Kb. Eso en cualquier arquitectura de PC significa
que el bloque devuelto va a ser de 4K, por lo que vamos a tomar este
valor. Veamos cómo crece el consumo de RAM respecto a la cantidad de
10 -> 40K
100 -> 400K
1 000-> 4M
10.000 -> 40M
100.000 -> 400M
Con la opción que yo digo, el máximo sería 8K, aparte del ahorro en la
fragmentación de la memoria.
Creo que vale la pena complicarse un poco la vida y ahorrar esa cantidad
de memoria. Aunque el algoritmo no sea "políticamente correcto", es mucho
más eficaz.
Imagina que en lugar de 1K fueran 10K, o 10K. Imagina que ejecutas en una
PDA, o en una placa con 64K.
Aparte, tu algoritmo podría calcular 100 números primos (por ejemplo)
antes de agotar la memoria mientras que el mío podría calcular tantos como
diera el tamaño de la pila de llamadas.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
Me he mirado tu código con más atención y tiene un fallo, debido a que
cada nivel no limpia sus cosas.
Suponiendo que realmente quieres utilizar cada vez una memoria diferente
apuntada por el mismo puntero, vigilas correctamente la primera llamada
para no hacer un delete sin sentido, pero te olvidas de hacer un delete
despues de la última salida. Cuando se acaba la recursividad 'p' apunta a
algo, que no has borrado. Es el problema cuando un nivel tiene que hacer
delete de un new de otro nivel. Es recomendable que cada new tenga su
delete en el mismo nivel.

Post by Zephryn Xirdal
Si la memoria no te sirve ya en la llamada recursiva, puedes liberarla a
la entrada de ésta excepto la primera vez, ahorrarás enormes cantidades
de ella y mejorarás el rendimiento, amén de evitar fragmentación, pues
si el bloque alojado de nuevo tiene el mismo tamaño o menos, se
char *p;
bool recursivo(bool primero)
{
if(!primero)
delete p;
p=new tal
recursivo(false);
}
etc.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
La norma que recomiendo, es liberarla en el mismo nivel en que se asigna.
entrada funcion recursiva
asingnar memoria A
hacer cosas, entre ellas las llamadas recursivas necesarias
liberar memoria A
salir de la recursion

Post by Ricardo
Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?
http://www.geocities.com/ricardo_rios_sv/index.html

[Zephryn Xirdal]

Pozí, te he respondido.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
Yo nunca he tenido que volver a trabajar con placas pequeñas, desde que
dejé el Z80, gracias a Dios. Y, francamente, espero no tener que meterme
en PDA. ;-)
Y dado que el que inició el hilo, no ha puesto ningún ejemplo de lo que
pretendía hacer y no le salía, no creo que podamos ayudarle más.
De todas maneras soy de la opinión personal que si tienes una función
recursiva que te tiene que trabajar a más de 10-15 niveles la debes usar
para testear una función iterativa que sea la que realmente haga el
trabajo en el programa final. Siempre será más eficiente.
P.D.: Te he mandado un mensaje ajeno a este hilo a gmail

Post by Zephryn Xirdal
Coñe, simplemente era una indicación. Claro que no libera al final, ni
existe condición de salida, por lo que el código terminará colapsando el
ordenador...
Respecto a tu post anterior, si conoces el tamaño máximo de la memoria,
evidentemente, es mejor, pero si no, te toca hacerlo de una de las dos
otras formas.
Yo sigo pensando que es mejor la mía. Imagina que en cada llamada vas a
asignar un bloque de 1Kb. Eso en cualquier arquitectura de PC significa
que el bloque devuelto va a ser de 4K, por lo que vamos a tomar este
valor. Veamos cómo crece el consumo de RAM respecto a la cantidad de
10 -> 40K
100 -> 400K
1 000-> 4M
10.000 -> 40M
100.000 -> 400M
Con la opción que yo digo, el máximo sería 8K, aparte del ahorro en la
fragmentación de la memoria.
Creo que vale la pena complicarse un poco la vida y ahorrar esa cantidad
de memoria. Aunque el algoritmo no sea "políticamente correcto", es mucho
más eficaz.
Imagina que en lugar de 1K fueran 10K, o 10K. Imagina que ejecutas en una
PDA, o en una placa con 64K.
Aparte, tu algoritmo podría calcular 100 números primos (por ejemplo)
antes de agotar la memoria mientras que el mío podría calcular tantos
como diera el tamaño de la pila de llamadas.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
Me he mirado tu código con más atención y tiene un fallo, debido a que
cada nivel no limpia sus cosas.
Suponiendo que realmente quieres utilizar cada vez una memoria diferente
apuntada por el mismo puntero, vigilas correctamente la primera llamada
para no hacer un delete sin sentido, pero te olvidas de hacer un delete
despues de la última salida. Cuando se acaba la recursividad 'p' apunta
a algo, que no has borrado. Es el problema cuando un nivel tiene que
hacer delete de un new de otro nivel. Es recomendable que cada new tenga
su delete en el mismo nivel.

Post by Zephryn Xirdal
Si la memoria no te sirve ya en la llamada recursiva, puedes liberarla
a la entrada de ésta excepto la primera vez, ahorrarás enormes
cantidades de ella y mejorarás el rendimiento, amén de evitar
fragmentación, pues si el bloque alojado de nuevo tiene el mismo tamaño
char *p;
bool recursivo(bool primero)
{
if(!primero)
delete p;
p=new tal
recursivo(false);
}
etc.
--
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
========================================
El hogar es la prisión de la doncella y el taller de la mujer.
-- George Bernard Shaw. (1856-1950) Dramaturgo irlandés.

Post by Bartomeu
La norma que recomiendo, es liberarla en el mismo nivel en que se asigna.
entrada funcion recursiva
asingnar memoria A
hacer cosas, entre ellas las llamadas recursivas necesarias
liberar memoria A
salir de la recursion

Post by Ricardo
Hola amigos, tengo una funcion recursiva dentro de esta funcion asigno
memoria dinamicamente a un arreglo de numeros flotantes, mi pregunta
es Cuando debo liberar la memoria?
http://www.geocities.com/ricardo_rios_sv/index.html