Foro de elhacker.net

Hola me surgio una duda ayer mientras programaba , estaba creando un metodo que añadia elementos a una colección y me  surgio la duda , ¿retorno void o retorno el nodo creado ? , en casi todas las implementaciones retornan void y mi pregunta es ¿porque? 

Quiero decir mejor retornar algo que pueda ser de utilidad en cierto momento que no retornar nada y fue cuando me puse a pensar si habia diferencia de rendimiento al usar uno u otro , alguien que me pueda guiar en mi duda ?


Gracias por su atencion.

PD: ¿cuando retornamos algo internamente donde lo estamos guardando en el stack interno donde tambien se guardan las variables locales o se guarda en memoria?

Tienes una casuístitca variada:

Puedes devolver void, en lenguajes como java es lo mas normal ( luego explicaré porque ), porque realmente el retorno de una función suele ser el producto de calcular algo respecto al estado interno de objeto.

Puedes devolver un bool: si se ha insertado o no ( puede que se te haya acabado la memoria ). Y aqui es donde la gente usa void, si algo pasase, normalmente se lanza una excepción.

Devolver el objeto insertado solo lo he visto hacer una vez, y personalmente le veo poco sentido.

Otra opción interesante es devolver toda la lista, esto te permite hacer cosas como:

miLista.add(1)
          .add(2)
          .add(3)
          .add(4)
          .add(5);


Pero gasta algo mas de memoria.


En resumen, pon VOID.  :laugh:

PD: Depende de la arquitectura, pero normalmente cuando sales de una función, el valor de retorno se mete en la pila y luego se desapila.

Habría que ver cual es la lógica del método que estás programando?
En que lenguaje? El método, es estático o de clase?

En fin, muchas cuestiones, Como bien dice Oblivi0n si la cuestión es añadir elementos a una colección no tiene sentido devolver nada, aunque podrías devolver algo para controlar que se ha añadido con éxito (bool, int).

En respuesta a tu pregunta, si se mete en la pila, pero también, la pila está en memoria!

Por eso con métodos recursivos cuyos casos de parada no están correctamente determinados, puedes recibir StackOverflow, pues la pila se llenó, o sea, se llenó la memoria.

Salu2s

Devolver un objeto, depende de si es necesario devolver un valor para una operación concreta o para operaciones que pueden realizarse. Imagina el siguiente escenario:

public class Rectangle {
	private Integer y;
	private Integer x;
 
	public Rectangle() {
 
	}
	public Rectangle(Integer x, Integer y) {
		this.x = x;
		this.y = y;
	}
	public Integer getY() {
		return y;
	}
	public Rectangle setY(Integer y) {
		this.y = y;
		return this;
	}
	public Integer getX() {
		return x;
	}
	public Rectangle setX(Integer x) {
		this.x = x;
		return this;
	}
}

Entonces, puedes hacer algo así:

Rectangle rectangle = new Rectangle().setY(5).setX(5);

O también:

Rectangle rectangle = new Rectangle();
rectangle.setY(5);
rectangle.setX(5);

El programador tiene 3 formas de hacer lo mismo, y él usará la que crea conveniente. Ésto aporta flexibilidad.

Respecto a rendimiento, no creo que haya ninguna diferencia en lenguajes modernos. En Java por ejemplo, si creas un objeto dentro de un método, éste se guarda en el HEAP, si es un primitivo en el STACK. Pero ésto no supone un problema de rendimiento, ya que el Garbage Collector lo desechará del HEAP cuando ya no haya ninguna referencia a él.

En la librería estándar de C++, list::insert(...) (http://www.cplusplus.com/reference/list/list/insert/) retorna un iterador al valor insertado.
Sin duda más útil que sin retorno.

Gracias por responder, pero creo que al usar mi ejemplo os he confundido con lo que estoy preguntando, el ejemplo era solo eso un ejemplo que no tiene porque tener mucho sentido.


Mi pregunta es, ¿cual es la diferencia entre retornar algo y nada en términos de rendimiento?

En cuanto a los lenguajes supongan de los normales, java c++, c y phyton, no se muy bien internamente cuales serán las diferencias pero creo que la política a seguir para devolver valores en los distintos lenguajes serán bastante similares.

Y de nuevo gracias por responder.

Como te había dicho, depende del método. Imagina que tienes una variable int en tu método, el hecho de hacer

return variable;

es O(1). por una constante (que depende del ordenador)

Pero si no devuelves nada, también hay un orden temporal de complejidad (imperceptible), porque el compilador realiza funciones, para entrar y salir del método con el Stack (asi como desempilar las cosas que se modificaron(o no)).

Si el método es void, lo que pasa es que la diferencia en cuanto a rendimiento será imperceptible.

Tambien hay que ver a que te refieres con rendimiento (memoria, tiempo?)

PD: Hablo en relación a C# y .NET, no estoy muy seguro en otros lenguajes.

En cuestión de rendimiento todas son iguales. La diferencia sería imperceptible.

Tal vez, la diferencia sea un push y un pop de la pila, en el mejor de los casos.

muchas gracias a todos , ya tengo clara la idea , lo marco como solucionado