Überladen von Funktionen ->Funktionspolymorphie

[Gast001]

Ich habe gerade in einem Büchlein gelesen das man einer Funktion verschiedene Parameter übergeben kann ( int, long etc. ).
Jetzt steht dort das man anstatt 4 Funktionen zu machen

int DoubleInt(int);
long DoubleLong(long);
float DoubleFloat(float);
double DoubleDouble(double);

nur eine braucht die man überläd:

int Double(int);
long Double(long);
float Double(float);
double Double(double);

(Funktionsprototypen)

Ich: "Ist ja geil, da spart man ja Code!" - Denkste, nun kommt das Beispiel aus dem Buch dazu:

int Double(int original)
{    
cout << "In Double(int)\n";    
return 2 * original;  
} 

long Double(long original)  
{   
cout << "In Double(long)\n";    
return 2 * original;  
} 

float Double(float original)
{
cout << "In Double(float)\n";
return 2 * original;57:  
}

double Double(double original)
{
  cout << "In Double(double)\n";
  return 2 * original;
}

Es gibt trotzdem 4 Funktionen. Wo spart man da bitteschön etwas oder was hat man davon? Eigentlich ist es ja eine Funktion aber man muss den Code trotzdem 4 mal niederschreiben. Gibts keine Möglichkeit in eine Funktionen int, long, char usw zu geben? Muss man wirklich für jeden Parameter eine eigene Funktion erstellen? Keine Chance?

[personenkult]

man spart nicht wirklich code.. aber du hast am Ende 1ne Funktion die mit verschiedenen Datentypen als Parameter umgehen kann. Was besser ist, als für jeden Datentyp eine extra Funktion zuschreiben.

[Gast001]

Also gibt es nicht so etwas wie

zauberwort Funktion_die_alle_Werte_verarbeitet(zauberwort) ?

Gut, wieder ein Tick mehr Wissen!

[peterchen]

Wo spart man da bitteschön etwas

Wenn man die Funktion aufruft :p

Im ernst: Der Sinn von überladenen Funktionen ist ja nicht code zu sparen (das was du suchst, kann man mit templates erreichen.)

Überladene Funktionen könenn helfen, eine Schnittstelle syntaktisch übersichtlicher und klarer zu machen. Oder genau das Gegenteil erriechen.

[edit]
Templates: verschiedene Typen mit syntaktisch gleicher Imlementation
Überladene Funktionen/Operatoren: gleiche Signatur mit üblicherweise unterschiedlicher Implementation
[/edit]

[Knuddlbaer]

Beispiel als Template:

#include <iostream>

using namespace std;

template<class T>
T Double(T a)
{
	cout<<"In Double("<<typeid(T).name()<<")\n";
	cout<<"Uebergebener Wert: "<<a<< "\n\n";
	return a;
}

int main(int argc, char* argv[])
{
	Double(12);
	Double(13l);
	Double("14");
	Double(15.0);
	Double(16.001l);

	return 0;
}