3. Operator Problem

Operator Problem

  • ?

    Hi, habe folgendes Problem und keine Loesung beim schreiben eines Operators. Der Operator soll Die Sitzplaetze der im Feld angelegten Busse addieren.
    Zum ersten, wie schreibe ich den Operator und gebe die ganze Sache dann am besten aus. Wie wuerdet ihr das machen. Danke schn mal im vorraus.

    ps: habe einen meiner vielen versuche unten auskommentiert

    #include <iostream>
#include <string>

using namespace std;

class Fahrzeug
{
protected:
	string Name;

public:

	Fahrzeug(string n) : Name(n){}

	virtual void out(void){cout<<"Fahrzeug(Fahrzeug) ist ein "<<Name<<endl;}   
  virtual int calc(void) {  } 
};

class PKW : public Fahrzeug
{
protected:
	string Typ;

public: 
	PKW(string n, string t) : Fahrzeug(n),Typ(t){}

	void out(void){cout<<"Fahrzeug(PKW) ist ein "<<Name<<" vom Typ "<<Typ<<endl;}

};

class LKW : public Fahrzeug
{
protected:
	int Gewicht;

public: 
	LKW(string n, int g) : Fahrzeug(n),Gewicht(g){}
	void out(void){cout<<"Fahrzeug(LKW) ist ein "<<Name<<" und wiegt "<<Gewicht<<" Tonnen."<<endl;}

};

class Bus : public Fahrzeug
{
protected:
	int Sitzplaetze;
	int Gesammt;

public:

	Bus(string n, int s) : Fahrzeug(n),Sitzplaetze(s){}
	void out(void){cout<<"Fahrzeug(Bus) ist ein "<<Name<<" und hat "<<Sitzplaetze<<" Sitzplaetze."<<Gesammt<<endl;}
	//Bus operator+(Bus a) { a.Gesammt = a.Sitzplaetze + a.Sitzplaetze; return Gesammt; }
	//int calc(void) { Gesammt =Gesammt + Sitzplaetze ;return Gesammt; } 

};

#include "klassen.h"
using namespace std;

int main(int argc, char* argv[])
{

	int Anzahl, f;
	cout<<"Wieviele Fahrzeuge: ";
	cin>>Anzahl;

	Fahrzeug *pfeld[Anzahl];
	for(int i=0;i<Anzahl;i++)
	{
	    cout<<endl<<"Fahrzeugtyp waerhlen: "<<endl;
	    cout<<"[1] PKW"<<endl<<"[2] LKW"<<endl<<"[3] Bus"<<endl;
	    cin>>f;

		switch (f)
		{
		  case 1:{pfeld[i] = new PKW("Porsche", "Sportwagen");break;}     
		  case 2:{pfeld[i] = new LKW("Ikarus" , 15);break;}            
		  case 3:{pfeld[i] = new Bus("Omnibus" , 30);break;}

        } 

	}

	for(int i=0;i<Anzahl;i++)
	{

	  pfeld[i]->out();
    }
    system("Pause");
	return 0;
}
    0
  • V

    Was bekommst du denn als Fehler?

    mfg
    v R

    0
  • B

    Es gibt eine einfache Grundregel für arithmetische Operatoren: Der += Operator wird als Memberfunktion implementiert, der + Operator als freie Funktion (das gilt natürlich auch für alle anderen, + sei hier nur stellvertretend.) Also ungefähr so:

    // ich übernehm dein Beispiel nicht 1:1, weil ich zu faul bin ... pass es dir an
class Bus {
  int sitze;
public:
  Bus& operator+=(Bus const& other);
};

Bus& Bus::operator+=(Bus const& other) {
  sitze += other.sitze;
  return *this;
}

Bus operator+(Bus const& einBus, Bus const& nocheinBus) {
  Bus temp(einBus);
  temp += nocheinBus;
  return temp;
}

    EDIT: const vergessen :^)

    0
  • O

    sorry für die dumme frage, aber wieso macht man das?

    0
  • B

    Es ist sehr einfach, die Implementierung des + Operators ist praktisch von der Stange, es wird ein Minimum an temporären Objekten erzeugt(NRVO ist möglich) ... was will man mehr?

    0
  • C

    Damit man z.b. auch (5 + Klasse) schreiben kann und nicht nur (Klasse + 5).
    Wenn du den Operator + als Klassenmethode definierst, kannst du bloß (Klasse + 5) aufrufen, da nur ein Wert vom Operator erwartet wird.
    Beispiel:

    Bus operator+(int value)
{
    // mach was
}

    Auch werden beide bei einer globalen Funktion nun gleich behandelt, was ja der Sinn von diesem Operator ist.

    0
  • S

    @Bashar: Ist das Erzeugen eines Temporären Objekts im op+ guter Stil? Ich habs bisher immer mit Friends gelöst...

    MfG SideWinder

    0
  • O
     

    Bus operator+(Bus const& einBus, Bus const& nocheinBus) {
  Bus temp(einBus);
  temp += nocheinBus;
  return temp;
}

    könnte man das nicht besser so schreiben?

    Bus operator+(Bus const& einBus, Bus const& nocheinBus) {
  return einBus+nocheinBus;
}

    wär das nich etwas schneller?

    0
  • B

    Otze: Nein, das wird eine sehr sehr langwierige Endlosrekursion 😉

    Sidewinder: Hm, du meinst so?

    Bus operator(Bus const& einBus, Bus const& nocheinBus) {
  return Bus(einBus.sitze + nocheinBus.sitze);
}

    Oder noch anders?

    Um das temporäre Objekt würd ich mir keine Gedanken machen, wenn ich einen halbwegs modernen Compiler benutze. Das wird per NRVO wegoptimiert.

    0
  • S

    Jop genau so, hab das bisher immer so gemacht. Also hat das keinen Sinn und heißt im Endeffekt nur Aufwand und Abhängigkeit?

    MfG SideWinder

    0
  • S

    Für deinen op+ könnte man ja glatt den <utility> um ein op+-Template erweitern.

    MfG SideWinder

    0
  • ?

    Bashar schrieb:

    Otze: Nein, das wird eine sehr sehr langwierige Endlosrekursion 😉

    Sidewinder: Hm, du meinst so?

    Bus operator(Bus const& einBus, Bus const& nocheinBus) {
  return Bus(einBus.sitze + nocheinBus.sitze);
}

    Oder noch anders?

    Um das temporäre Objekt würd ich mir keine Gedanken machen, wenn ich einen halbwegs modernen Compiler benutze. Das wird per NRVO wegoptimiert.

    Was ist NRVO?

    0
  • C

    unwissender4 schrieb:

    Was ist NRVO?

    Ich glaube das heißt: "Named Return Value Optimization"
    Bin mir aber nicht sicher 🙄

    0
  • B

    Jep, zur Not könnte man sich das auch ergoogeln :p

    0
  • V

    Bashar schrieb:

    Jep, zur Not könnte man sich das auch ergoogeln :p

    Optimist 😉

    mfg
    v R

    0
  • S

    Und was ist jetzt mit meinem op, lieber friend oder so? 🙂

    MfG SideWinder

    0
  • B

    Dein operator braucht einen passenden Konstruktor, aber ansonsten ist dagegen imho nichts einzuwenden.

    0
Anmelden zum Antworten