3. Was bringt es Funktionen zu überladen ?

Was bringt es Funktionen zu überladen ?

  • M

    Guten Abend
    Ich habe heute Abend Funktionen überladen "durchgenommen"
    Ich habe es verstanden wie es geht, aber den genauen Sinn davon verstehe ich nicht, ich habe mal ein Beispiel geschrieben welches Funktionen überlädt - siehe weiter unten.
    Ich verstehe nicht was bringt es jetzt eine Funktion zu überladen ich könnte doch genausogut eine neue Funktion schreiben, denke ich zu kompliziert wie ich es von mir gewohnt bin oder was verstehe ich da nicht ...
    liebe grüße

    // Functionsüberladung.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include "stdafx.h"
#include <iostream>
using namespace std;

//Funktions-Prototyp
int do_stuff( int par );
int do_stuff( int par1, int par2 );
double do_stuff( double par );
double do_stuff( double par1, double par2);
void do_stuff( ... );

int main()
{
	int var1;
	double var2;
	var1 = do_stuff( 10 );
	cout << var1 << '\n';
	var2 = do_stuff( 10.2 );
	cout << var2 << '\n';
	var1 = do_stuff( 10, 11 );
	cout << var1 << '\n';
	var2 = do_stuff( 10.11, 11.22 );
	cout << var2 << '\n';
	do_stuff( 'a', 'b', 'c' );
	cin.get();
	return 0;
}

//Funktionsdefinition
int do_stuff( int par )
{
	return ( par * 2 );
}

int do_stuff( int par1, int par2 )
{
	return ( par1 * par2 );
}

double do_stuff( double par )
{
	return ( par* 2 );
}

double do_stuff( double par1, double par2 )
{
	return ( par1 * par2 );
}

void do_stuff( ... )
{
	cout << "Fehler: Falscher Funktionsaufruf!\n";
}
    0
  • 3

    Huhu,

    Gute Frage. Die Frage ist wohl am einfachsten beantwortet, indem ich dir verrate, dass du Überladung die ganze Zeit schon verwendet hast. Warum kannst du

    cout << 42 << 3.14 << "blubb";

    schreiben? Der operator << ist für jeden eingebauten Datentyp sowie ein paar andere überladen. Der Vorteil ist, dass es für jeden Typen gleich funktioniert.

    Grüße,
    PI

    0

  • Miriiam schrieb:

    Ich verstehe nicht was bringt es jetzt eine Funktion zu überladen ich könnte doch genausogut eine neue Funktion schreiben, denke ich zu kompliziert wie ich es von mir gewohnt bin oder was verstehe ich da nicht ...

    Du schreibst doch eine neue Funktion!? Die hat nur den gleichen Namen wie eine bereits vorhandene.
    Überleg mal wie du deine Funktionen benennen müsstest, wenn du kein Overloading hättest.
    Und dann überleg was das für dein Beispiel bedeuten würde, wenn du nun var2 plötzlich doch lieber als int hättest...

    0
  • V

    Dein Beispiel do_stuff ist kacke, fürchte ich.

    int quadrat(int i);
    double quadrat(double d);
    float quadrat( float f);

    "quadrat" bedeute einfach immer das selbe irgendwie. Dann ist Überladen gut. Aber wenn man den selben Namen mit verschiedenen Bedeutungen überlädt, soll man sich besser einen Bolzenschussapparat nehmen. (In Javascript sind Pseudoüberladungen (Sprache hat zwar direkt keine Überladungen, aber man kann die Parameter zählen und deren Typen bestimmen) mit Bedeutungswechsel leider üblich, und stets ist es undokumentiert.)

    Das wäre ja, die zauberhaften Sprachmittel von C++ dazu zu verwenden, daß man den Code danach im Vergleich zu klassischem Code schlechter lesen kann. Das ist sicherlich nicht im Sinne des Erfinders.

    Überladung erleichtert das Pr0ggern, wenn mit dem selben Namen voll ähnliche Aktionen gemeint sind. Zum Beispiel "wegmachen, vernichten, Ressourcen ans Betriebssystem freigeben, löschen" ist so ein Ding, das man gerne generell einfach close nennt. Was genau geclosed wird, hängt vom Typ des Parameters ab. Und was genau passiert, natürlich genauso. Für mich ist es einfach close und gut ist's.

    0
  • M

    Danke für eure Antworten ich habs jetzt so ziemlich verstanden.

    überleg was das für dein Beispiel bedeuten würde, wenn du nun var2 plötzlich doch lieber als int hättest...

    dann müsst ich schreiben:
    var2 = do_stuff( 10 );
    oder
    var2 = do_stuff( 10, 11 );
    Dann wäre es wieder Int oder ?

    Danach kommt ein Beispiel in dem Funktionen mit Standartparametern überladen werden, es wird gesagt das wenn sich die einzelnen Parameter nicht grundlegend unterscheiden sollte man Standartparameter der Funktionsüberladung vorziehen, ich verstehe nicht warum im ersten Beispiel 3 Funktionen genutzt werden und in dem 2ten mit den Standartparametern nur eine die die möglichkeiten von 3 hat...
    ich will es ganz verstehen ..
    Kann ich nicht einfach eine Funktion machen in etwa so:

    int funktion( int par1, int par2, int par3)

float var;
var = funktion( 1.3 )

    ?
    Würd mich über eine detailreiche Antwort freuen!

    // FunctionsüberladungmitStandartParametern.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include "stdafx.h"
#include <iostream>
using namespace std;

double do_stuff( double par1, double par2 = 2.0 );
void do_stuff( ... );

int main()
{
	int var1;
	double var2;
	var1 = do_stuff( 10 );
	cout << var1 << '\n';
	var2 = do_stuff( 10.2 );
	cout << var2  << '\n';
	var1 = do_stuff( 10, 11 );
	cout << var1 << '\n';
	var2 = do_stuff( 10.1, 11.2 );
	cout << var2 << '\n';
	do_stuff ( 'a', 'b', 'c' );
	cin.get();
	return 1337;
}

double do_stuff( double par1, double par2 )
{
	return ( par1 * par2 );
}

void do_stuff( ... )
{
	cout << "Fehler bei der Eingabe!\n";
}
    0
  • V

    volkard schrieb:

    Dein Beispiel do_stuff ist kacke, fürchte ich.

    0

  • Miriiam schrieb:

    Danke für eure Antworten ich habs jetzt so ziemlich verstanden.

    überleg was das für dein Beispiel bedeuten würde, wenn du nun var2 plötzlich doch lieber als int hättest...

    dann müsst ich schreiben:
    var2 = do_stuff( 10 );
    oder
    var2 = do_stuff( 10, 11 );
    Dann wäre es wieder Int oder ?

    Nein, der Punkt ist, dass deine Funktionen ohne Overloading eben genau nicht alle do_stuff() heißen könnten, sondern verschiedene Namen haben müssten.
    Du müsstest sie dann also z.B. do_stuff_int_1_parameter() , do_stuff_int_2_parameters() , do_stuff_double_1_parameter() etc. nennen.
    Und welche davon aufgerufen wird, bestimmen ohne Overloading eben nichtmehr automatisch die Typen der Parameter. D.h. wenn du dein var2 nun von double auf int ändern willst, dann musst du auch sämtliche Funktionsaufrufe durchsuchen und auf die entsprechenden double Varianten umändern...und wehe du übersiehst dabei wo was...

    Hör was volkard sagt 😉

    0
  • R

    Bei kleineren Programmen ist das Überladen von Funktionen eher nur Übung, als wirklich sinnvoll zu sein.

    Aber bei Programmen mit mehreren tausend Zeilen Code dürfte das schon anders aussehen.

    Wenn man da ähnliche Funktionen anders benennen müßte, würde die Übersichtlichkeit wohl nicht wenig leiden.

    0

  • Overloading ist eben ein gutes Werkzeug für viele Fälle. Und so einen Anwendungsfall hat man oder eben nicht, mit der Größe der Programme hat das absolut nichts zu tun.

    0
  • R

    dot schrieb:

    Overloading ist eben ein gutes Werkzeug für viele Fälle. Und so einen Anwendungsfall hat man oder eben nicht, mit der Größe der Programme hat das absolut nichts zu tun.

    Hat das Überladen von Funktionen noch einen anderen Vorteil ausser dem der besseren Lesbarkeit des Programms?

    0
  • Mod

    Dürfen kleine Programme nicht übersichtlich sein?

    0

  • Ja, hab ich ja oben schon beschrieben. Z.B. gestalten sich Programmänderungen einfacher.

    0
  • E

    redrew99 schrieb:

    dot schrieb:

    Overloading ist eben ein gutes Werkzeug für viele Fälle. Und so einen Anwendungsfall hat man oder eben nicht, mit der Größe der Programme hat das absolut nichts zu tun.

    Hat das Überladen von Funktionen noch einen anderen Vorteil ausser dem der besseren Lesbarkeit des Programms?

    Klar, wenn es um generische Programmierung geht.

    0
Log in to reply