Métodos sobrecargados vs métodos repetidos
 

Acabo de abrir una encuesta en la comunidad de Desarrolladores Delphi de Google Plus

La encuesta reza lo siguiente:

Que crees que es mejor? (teniendo en cuenta gustos, legibilidad, flexibilidad, performance.. lo que se les venga a la cabeza)

Metodos sobrecargados:

Código Delphi [-]
procedure Foo(const Text: string); overload;
procedure Foo(const Text: string; const Args: array of const); overload;

Metodos "separados":

Código Delphi [-]
procedure Foo(const Text: string);
procedure FooFmt(const Text: string; const Args: array of const);

Traduciendo mi respuesta del ingles:

Yo voto por la opcion de metodos sobrecargados, sobre todo por la legibilidad y porque se escribe menos.

Ademas, da la sensacion de que la clase es mas simple porque parece que hay "menos metodos"

Por ultimo, el IDE es capaz de mostrar al mismo tiempo todas las "posibilidades" del metodo en cuestion. De esa manera obtengo en un instante mas informacion de que puede hacer la clase, sin tener que ponerme a revisar si "habra algun metodo que hace lo mismo del string pero que me permita pasarle el arreglo para el Format? o tengo que invocar yo mismo a Format?"

Los métodos sobrecargados me parecen mucho más cómodos por legibilidad y todo lo que acabas de mencionar... de hecho he notado que las nuevas bibliotecas de otros lenguajes han apelado por este tipo de técnicas para lograr tener descripciones claras sin necesidad de ser tan largas (Aunque a veces sí tengan que ser largas si se trata de no sacrificar claridad).

Idem. por lo mismo :D

Como bicho raro y amante del C/C++ estoy muy acostumbrado a la sobrecarga. En C/C++ es algo tan natural, que no hay ni que especificarla, basta con que los parámetros sean diferentes.
Voto por la sobrecarga.

Coincido con todo lo dicho y sumo un voto a la sobrecarga.

Saludos :)

+1

Nunca entendi porque en Pascal tenemos que avisarle al compilador que estamos sobrecargando un metodo

A mi muchas veces me molesta porque me suele pasar que el agregar overload provoca que el texto sobrepase el margen derecho, y luego al pasarle el formatter me ponga el overload en la siguiente linea. (Se que puedo ampliar este margen, pero eso tendria otros efectos no deaseados. El valor que tengo me deja contento para todos los casos, siendo este la excepcion)

Otra cosa que me molesta de la sobrecarga, esta relacionada con las funciones. En "teoria", una funcion en Pascal no es mas que un procedimiento donde el valor de retorno es un parametro implicito de salida (out) y tiene por nombre Result. Si ese fuera el caso, el compilador podria diferenciar entre las invocaciones:

Código Delphi [-]
  // error de compilacion, E2252 Method 'Bar' with identical parameters already exists
  TFoo = class
  public
    function Bar: Integer; overload;
    function Bar: string; overload;
  end;

Sin embargo, si usamos un procedure con un parametro de salida out, si que compila:

Código Delphi [-]
  TFoo = class
  public
    procedure Bar(out Result: Integer); overload;
    procedure Bar(out Result: string); overload;
  end;

Uds llaman a los overload y les subo la apuesta a los multi-methods:

https://en.wikipedia.org/wiki/Multiple_dispatch
https://julia.readthedocs.io/en/latest/manual/methods/

(O tambien conocido como multi-overload... multi-sobrecarga?)

La diferencia? En la forma simple, el primer parámetro no se sobrecarga (siendo este de forma implícita en delphi "self"). En cambio, de la forma full se sobrecarga sobre todos los parámetros.

En el caso de Julia, es innecesario crear clases solo para sobrecargar un metodo, ya que se puede aplicar de forma universal.

Soy el único que ha votado "repetidos". Pues vaya.

No es que esté en contra de la "sobrecarga". Lo que me ocurre es que creo que cuando he necesitado sobrecarga en realidad era para hacer algo ligeramente distinto. El ejemplo que pones, Agustin, sin ir más lejos, es un claro ejemplo. En el segundo método estás formateando, en el primero no. :p Vale, no siempre es así, pero me gusta que un método admita un único tipo de dato. De esta forma sé qué es lo que está haciendo, y si hay que realizar conversiones me aseguro de que la conversión que hace es la que quiero. Precisamente la conversión de tipos fue una de las principales razones por las que abandoné C++ para siempre.

Y a mi me parece muy bien que haya que decirle al compilador que quieres sobrecargar, precisamente para evitar errores. La de dolores de cabeza que me ha dado C++ precisamente porque no me decía que estaba sobrecargando y llamando a un método diferente por cosas de la precedencia. Con Pascal no pasa, porque avisa.

A mi lo que me sorprende es la pregunta en sí. Esto es, ¿hay alguien de verdad que piense que no es buena la sobrecarga? ¿Es realmente materia de debate? Desde luego la sobrecarga da mayor elegancia y claridad al código. Claro que también hay que atender a lo que menciona Ñuño y no abusar de esta técnica.

En cuanto a esto:

Creo que tiene que ver con el hecho de que el compilador de delphi recorre una sóla vez el código a dferencia del de C que lo hace más de una vez.

LineComment Saludos

La sobrecarga de métodos es una solución elegante al problema de cómo nombrar a dos rutinas pertenecientes a la misma clase y que hacen la misma tarea, y cuya funcionalidad sólo se diferencia por los parámetros que acepta. En lo de misma tarea hay que hacer hincapié, ya que puede ser tentador llamarle de la misma manera a diversos métodos que desempeñan funciones muy diferentes, con la venia de que los parámetros supuestamente despejan cualquier duda de qué es lo que el programa va a hacer cuando se llame a un método o a otro. Dentro de una clase debemos evitar la sobrecarga de un método más allá de una sola funcionalidad general definida para todas las versiones que se escriban del mismo. Dos funcionalidades no tan semejantes y nombradas de la misma manera en el mismo contexto podría ser considerado una mala práctica (lección que aprendí en años recientes).

Mi voto es para los métodos sobrecargados puestos con juicio.

Es porque Pascal, a diferencia de lenguajes sádicos como C++, previene al programador de cometer muchas pequeñas pifias que de otro modo tendrían repercusiones después, incluso en tiempo de ejecución. Escribiste SetData queriendo escribir SetDate, pero el impertérrito compilador de C++ determinó que querías definir una sobrecarga del ya existente método SetData.

Lo dicho es debido a que una función, por lo general, también puede ser ejecutada como procedimiento:

Código Delphi [-]
Foo1.Bar;  // ¿A cuál de los dos métodos función "Bar" estoy llamando?

Un abrazo.
Un abrazo (sobrecargado).

Al González. :)

En G+ discutimos el tema de la sobrecarga de funciones según su retorno.

Lo único más o menos viable (y que tiene problemas y no aporta nada, más que un capricho del buen Agustín) es que el compilador evalúe el contexto de invocación a la función

Código Delphi [-]
Foo1.Bar // ambigüedad
VarString := Foo1.Bar; // puede determinar que es la función que devuelve string
VarInteger := Foo1.Bar; // del mismo modo, como asigno en un integer, el compilador puede determinarlo

Obvio que hay muchos problemas. Y serían pocos los casos en los que el compilador podría ayudar, y muchos los que debería reportar un error de ambigüedad.

Básicamente termina pasando lo que enunciaste en el hilo del with. Todo elemento que nos dé la posibilidad de escribir código más elegante, bienvenido sea, siempre y cuando no comprometa la ambigüedad.

Imaginarse código bar*bar + bar.. termina siendo un rompecabezas para el humano, y algo que sólo el compilador puede entender

Y eso no es para nada útil

Roman con respecto a la pregunta es curiosidad; en G+ votaron apenas unas 100 personas, pero aún así, hay un 20% que prefiere la otra alternativa. Supongo que es cuestión de gustos

¿Estás seguro a ciencia cierta de que ésta es la razón?

LineComment Saludos