3. Wofür braucht man Polymorphie ?

Wofür braucht man Polymorphie ?

  • N

    noobLolo schrieb:

    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.

    0
  • ?

    hiho,

    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.

    0
  • ?

    Nexus schrieb:

    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

    0
  • ?

    Dweb schrieb:

    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.

    0
  • ?
     

    #include <iostream>
#include <string>

class Vehicle
{
	protected:
		double myPrice;
		int myWheels;
		std::string myName;

	public:
		Vehicle(double price, int wheels, const std::string& name) : myPrice(price), myWheels(wheels), myName(name) { }
		double getPrice() const { return myPrice; }
		int getWheels() const { return myWheels; }
		const std::string& getName() const { return myName; }
};

class Car : public Vehicle
{
	public:
		Car() : Vehicle(100, 4, "Car") {}
};

class Bike : public Vehicle
{
	public:
		Bike() : Vehicle(10, 2, "Bike") {}
};

void print(Vehicle& v);

int main()
{
	Vehicle *v = new Car();

	print(*v);

	delete v;

	v = new Bike();

	print(*v);

	delete v;
}

void print(Vehicle& v)
{
	std::cout << "Name: " << v.getName() << "\nPrice: " << v.getPrice() << "\nWheels: " << v.getWheels() << "\n" << std::endl;
}
    0
  • ?

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

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

    0
  • J

    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.

    0
  • ?

    Janjan schrieb:

    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.

    0
  • ?

    http://www.schule.de/schulen/oszhdl/gymnasium/faecher/informatik/oop/polymorphie.htm

    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.

    0
  • S

    poly schrieb:

    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.

    0
  • K

    Janjan schrieb:

    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.

    0
Anmelden zum Antworten