Wofür könnte man sowas z.b. gebrauchen irgendwie hab ich den sinn von Polymorphie noch nicht verstanden.

#include <iostream>
using namespace std;

int add ( int , int );
double add ( double,double );

int main()
{
int ret1;

double ret2;

ret1 = add ( 1,1);
ret2 = add ( 9.0 , 2.0);

cout<<"ret1: " << ret1 <<endl;
cout<<"ret2: " << ret2 <<endl;

system("PAUSE");

}

int add ( int z1, int z2)
{
int erg;

erg = z1+z2;
return erg;
}

double add ( double z1 , double z2)
{
double erg;

erg = z1 /z2;

return erg;

}

Wofür braucht man Polymorphie ?

das ist keine Polymorphie sondern einfache operator überladung. lies dich doch mal ein bischen in das thema ein, das internet bietet dafür schon ganz gute quellen die auch relativ einfach zu finden sind.

lg lolo

operator überladung.

meinte natürlich parameter überladung

lg lolo

das ist keine Polymorphie

Ich denke, das hängt von der Definition ab. Falls man unter Polymorphie versteht, unterschiedliche Aktionen einheitlich ansprechen zu können, kann man Funktionsüberladung dazu zählen. Genauso wie man Templateprogrammierung als statische Polymorphie auffassen kann.

Was du vielleicht meinst, ist Laufzeit- bzw. dynamische Polymorphie mittels virtueller Funktionen.

mein Prof. hatte uns damals folgendes Bsp. gezeigt:

#include <iostream>
using namespace std;

class Means_Of_Transport
{
    protected:
        int price;

    public:
        Means_Of_Transport(int price) : price(price) {}
        virtual ~Means_Of_Transport() {}
        virtual int getPrice() = 0;
};

class Car : public Means_Of_Transport
{
    public:
        Car(int price) :  Means_Of_Transport(price) {}
        virtual ~Car() {}
        int getPrice() { return price; }

};

class Bike : public Means_Of_Transport
{
    public:
        Bike(int price) :  Means_Of_Transport(price) {}
        virtual ~Bike() {}
        int getPrice() { return price; }
};

class Scooter : public Means_Of_Transport
{
    public:
        Scooter(int price) : Means_Of_Transport(price) {}
        virtual ~Scooter() {}
        int getPrice() { return price; }
};

int main()
{
    Means_Of_Transport* p = NULL;

    Car c(32000);
    p = &c;
    cout << "Car : " << p->getPrice() << endl;

    Bike b(799);
    p = &b;
    cout << "Bike : " << p->getPrice() << endl;

    Scooter s(1234);
    p = &s;
    cout << "Scooter : " << p->getPrice() << endl;

    cin.get();
    return 0;
}

Du kannst den Pointer also auf ein beliebiges Subklassen-Objekt setzen, und das Resultat stimmt.

hoff das hilft^^

[ EDIT ] Abgeändert nach fghgfhs Beitrag.

Was du vielleicht meinst, ist Laufzeit- bzw. dynamische Polymorphie mittels virtueller Funktionen.

#include <iostream>
using namespace std;

class vehicle{
public:
	virtual const char *getName(){
		return "";
	};
	virtual int getNumberOfWheels(){
		return 0;
	};
};

class car : public vehicle{
public:
	const char *getName(){
		return "car";
	};
	int getNumberOfWheels(){
		return 4;
	};
};

class bicycle : public vehicle{
public:
	const char *getName(){
		return "bicycle";
	};
	int getNumberOfWheels(){
		return 2;
	};
};

int main() {
	vehicle *data[2];
	data[0] = new car();
	data[1] = new bicycle();

	int l = 2;
	while(l--){
		cout << "a " << data[l]->getName() << " uses " << data[l]->getNumberOfWheels() << " wheels" << endl;
	}
	return 0;
}

ja an sowas denk ich iwie immer wenn das wort polymorphie fällt

lg lolo

hiho,

mein Prof. hatte uns damals folgendes Bsp. gezeigt:

#include <iostream>
using namespace std;

class Means_Of_Transport
{
    public:
        virtual ~Means_Of_Transport() {}
        virtual int getPrice() = 0;
    
};

class Car : public Means_Of_Transport
{
    private:
        int price;
        
    public:
        Car() : price(32000) {}
        virtual ~Car() {}
        int getPrice() { return price; }
        
};

class Bike : public Means_Of_Transport
{
    private:
        int price;
        
    public:
        Bike() : price(799) {}
        virtual ~Bike() {}
        int getPrice() { return price; }
};

class Scooter : public Means_Of_Transport
{
    private:
        int price;
        
    public:
        Scooter() : price(1234) {}
        virtual ~Scooter() {}
        int getPrice() { return price; }
};

int main()
{
    Means_Of_Transport* p = NULL;
    
    Car c;
    p = &c;
    cout << "Car : " << p->getPrice() << endl;
    
    Bike b;
    p = &b;
    cout << "Bike : " << p->getPrice() << endl;
    
    Scooter s;
    p = &s;
    cout << "Scooter : " << p->getPrice() << endl;
    
    cin.get();
    return 0;
}

Du kannst den Pointer also auf ein beliebiges Subklassen-Objekt setzen, und das Resultat stimmt.

hoff das hilft^^

Ich find das Beispiel aber nicht so schön. Man könnte die Variable für den Preis auch einfach protected machen und diese stattdessen ändern.

int add ( int , int );
double add ( double,double );

Aber wo ist der Sinn hier wofür kann man 2 mal denselben Funktions nahmen benutzen ?

int add ( int , int );
double add ( double,double );

Das ist keine Polymorphie, sondern Funktionsüberladung.

Und der Sinn ist einfach, dass du abhängig vom Typ unterschiedliche Funktionen aufrufen kannst, ohne ständig dafür einen neuen Namen zu nutzen. Das wird besonders nützlich, wenn du eigene Typen erstellst.

poly schrieb:

Aber wo ist der Sinn hier wofür kann man 2 mal denselben Funktions nahmen benutzen ?

int add ( int , int );
double add ( double,double );

Das ist keine Polymorphie, sondern Funktionsüberladung.

Und der Sinn ist einfach, dass du abhängig vom Typ unterschiedliche Funktionen aufrufen kannst, ohne ständig dafür einen neuen Namen zu nutzen. Das wird besonders nützlich, wenn du eigene Typen erstellst.

Ich würde eher sagen, es wird besonders nützlich in Verbindung mit Templates.
Als simples Beispiel würde ich einfach mal maximales Element in einem std::vector nennen.
Oder auf diese Funktionen bezogen, Summe aller Elemente eines std::vectors.

std::accumulate(vector.begin(), vector.end(), 0);

Die Template-Funktion verwendet (vermutlich - hab es nicht nachgekuckt) den
operator+, aber kann natürlich auch mit deiner add-Funktion implementiert werden.

Wenn man jetzt ne eigene Klasse z.B. für komplexe Zahlen macht und diese
Funktion implementiert, braucht man diese Funktion nicht neu schreiben.

Natürlich braucht man durch Funktionsüberladung auch ohne Template weniger
Funktionsnamen. In Verbindung mit Templates kann es nur besonders nützlich werden.

Polymorphie findest du z.B. in (fast) allen GUI Frameworks. Es gibt Buttons, Textfelder usw. die alle von einer Klasse (Widget) ableiten und die paint Methode überschreiben, so z.B. ein Dialog mehrere solcher Widgets enthalten kann und dann immer nur widget.paint aufruft und durch polymorphie wird dann immer entwas anderes gezeichnet.

Aber wo ist der Sinn hier wofür kann man 2 mal denselben Funktions nahmen benutzen ? ...

ich würde eher anders herum sagen: Warum sollte man 2 Funktionen, die (mit unterschiedlichen Typen) dasselbe machen, unterschiedlich nennen?

Gruß,

Simon2.

Das ist keine Polymorphie, sondern Funktionsüberladung.

Ueberladen ist auch eine Form von Polymorphie. Ich dachte, das wurde weiter oben schon geklaert ...

Ansonsten: Wurde denn schon mal http://de.wikipedia.org/wiki/Polymorphie_(Programmierung) bemueht. Da ist das + Beispiel erklaert.