eigener dateentyp

Gucky

aber wieso schreiben die das dann so hier?

Übliche Implementierung:
C/C++ Code: 
const X operator+(X const& lhs, X const& rhs) 
{ 
  /* Erzeugen eines neuen Objektes, dessen Attribute gezielt einzeln gesetzt werden. Oder: */ 
  X tmp(lhs); //Kopie des linken Operanden 
  tmp += rhs; //Implementierung mittels des +=-Operators 
  return tmp; 
}

HighLigerBiMBam

Ja außerhalb der Klasse!

Gucky

class BigNum 
{ 
public:
 vector<unsigned long> ziffern; 
 bool sign; 
}; 

BigNum operator+(BigNum const& lhs, BigNum const& rhs)
{
	BigNum tmp(lhs); //Kopie des linken Operanden 
	tmp = rhs + lhs; //Implementierung mittels des +=-Operators 
	return tmp; 
}

jetzt kommt es nur noch zu einem speicherüberfluss (warum weiß eich nicht) und ich kann nicht über einen konstruktor normal werte an ziffern übergeben.
Kann mir jemand sagen wie das geht bzw. wie ich vector als schablone für meinen eigenen datentyp benutzten kann??

HighLigerBiMBam

rhs + lhs das kann nicht klappen, du rfust ja den selben Operator REKURSIV auf. Du musst schon Methoden oder Werte zusammenrechnen.

volkard

Dann mußt Du auch += schreiben.

BigNum operator+(BigNum const& lhs, BigNum const& rhs)
{
	BigNum tmp(lhs); //Kopie des linken Operanden 
	tmp += rhs; //Implementierung mittels des +=-Operators 
	return tmp; 
}

jetzt kommt es nur noch zu einem speicherüberfluss

Will ich auch haben.

HighLigerBiMBam

Speicher im Überfluss ist immer gut :), ich frag mich aber dann nur, wie sein += Operator aussieht...

Gucky

muss ich jetzt was in operator+ steht auch in plus schreieben???

const X X::plus(X const& rhs) const; //Implementiert die Addition 
const X operator+(X const& lhs, X const& rhs) 
{ 
  return lhs.plus(rhs); 
}

ich versteh nicht ganz ób jetzt bei Implementiert die Addition noch was fehlt.

ich geh mal nicht davon aus aber wo muss ich es dann in meiner klasse unterbringen??

HighLigerBiMBam

Dann kannst du auch gleich; const X operator+( X const& rhs) (in der Klasse) machen. this (lhs) hast du ja eh. Volkards implementation ist natürlich korrekt, wenn du die Implementation im += Operator durchführst! Letztlich ist es egal was du machst, denn spätestens in der Implementation musst du die Klassen irgendwie addieren. Und dies musst du deiner Klasse beibringen. Bei einfachen Datentypen kannst du dies durch eine Gettermethode machen, aber bei Vectoren musst du zeigen, wie der vector von lhs und rhs zusammenaddiert werden!? Komponentenweise, oder einfach nur in einen vector schieben? All dies obliegt dir.

Gucky

HighLigerBiMBam schrieb:

this (lhs) hast du ja eh

wie kann ich das machen, dass das der operator weiß??
und volkhard schrieb zu anfangs mal, dass man vector als schablone benutzen kann??

wie muss ich das dann im main machen.
derzeit sieht es so aus, aber es klappt nicht so

#include <iostream>
#include <vector>
using namespace std;

class BigNum 
{ 
public:
	const BigNum BigNum::plus(BigNum const& rhs) const;
	BigNum operator+(BigNum const& lhs)
	{
		return lhs.plus(rhs);
	}	
	vector<unsigned long> ziffern; 
	bool sign; 
}; 

int main()
{
	BigNum v1;
	BigNum v2;
	BigNum v3;

	v1.ziffern = 123456789123445;
	v2.ziffern = 123456789;

	v3 = v1 + v2;
	return 0;
}

Felixxx

? In einer Klassenmethode kannst du immer this->Eigenschaft/Variable benutzen. Rufst du das mit objekt1 auf, werden die Eigenschaften von objekt1 verwendet, usw. Was meinst Du \\" dass der Operator das weiß\\" ? Was du eigentlich ja machen muss ist im Operator this.vector rechtesArgument.vector rechnen ?

HighLigerBiMBam

Lies dir das mal durch:
http://www.willemer.de/informatik/cpp/cppovrld.htm

So halt...

BigNum operator+(const BigNum &rhs) 
{ 
    //pseudocode
	BigNum temp = *this;

    for(vector<unsigned long>::const_iterator i = rhs.ziffern.begin(); i != rhs.ziffern.end(); ++i) 
    { 
        //korrekte mathematische Operation angeben (hier nur Beispiel) 
        temp.ziffern.push_back(*i); 
    } 

    return temp; 
}

l'abra d'or

HighLigerBimbam, da ist ja einiges böses am Werk...

obwohl du lhs NICHT veränderst gibst du eine nicht-konstante Referenz als Parameter mit
"lhs" ist Irreführend, da "this" darauf hindeutet, dass du in einer Memberfunktion bist und da eben "this" der lhs ist
Du gibst *this als value zurück, was direkt auf 4) zurückzufhühren ist
gaaanz böse: dein operator+ verändert this! Das ist ein nicht erwarteter und auch unsinniger Nebeneffekt.

c = a+b; // und a hat einen anderen Wert!! Ouch!

Wenn du Tips an einen Unerfahrenen gibst, sollten die auch bitte korrekt sein...

HighLigerBiMBam

Schön das wenigstens einer aufpasst.

Gucky

kann mir jemand sagen, was genau hier passiert:

temp.ziffern.push_back(*i);

ich hatte noch nie was mit so was zutun

BasicMan01

i ist in dem Fall ein iterator, der auf den Ort zeigt, wo sich der Wert befindet.
Um an den eigentlichen Wert zu kommen, verwendet man den Dereferenzierungsoperator *
mit push_back wird der Wert einem Container (in dem Fall vector) hinzugefügt. Also an das Ende angehängt.

Gucky

ich meine eigentlich temp.ziffern und es wird doch dann kein neuer wert übergeben so wie ich das verstehe

BasicMan01

Meine schöne kostbare Zeit, die gerade im Nirvana verschwindet

"ziffern" ist eine Instanz eines vectors, welche im public-Bereich der Klasse BigNum liegt. Auf öffentliche Variablen kann man direkt mittels "." zugreifen.
temp ist eine Instanz der Klasse BigNum. da ziffern wie gesagt öffentlich ist, kann man mit temp.ziffern auf dieses Objekt zugreifen.

Gucky

ich bekomme es nicht auf die reihe
ich müsste doch von hinten durch beide vectoren gehen die addieren will und dies dann so machen wie als wenn man schriftlich addiert.

wenn dies so gehen sollte versteh ich den ansatz von HighLigerBiMBam nicht

HighLigerBiMBam

Gucky schrieb:

ich bekomme es nicht auf die reihe
ich müsste doch von hinten durch beide vectoren gehen die addieren will und dies dann so machen wie als wenn man schriftlich addiert.

wenn dies so gehen sollte versteh ich den ansatz von HighLigerBiMBam nicht

Das mit push_back war auch nur ein Beispiel, wie man einen Operator überlädt. Du musst natürlich noch die Konkrete Berechnung selbst schreiben.

Gucky

so, ich hoffe, dass man das so machen kann

BigNum operator+(BigNum const& rhs)
	{
		BigNum temp = *this;
		short int v = 0;
		vector<unsigned long>::const_iterator j = temp.ziffern.end()-1;
		for(vector<unsigned long>::const_iterator i = rhs.ziffern.end()-1; i != rhs.ziffern.begin(); --i) // Bei der schrifltichen addition geht amn immer von rechts nach links
		{
			if (*i + *j + v >= 10)
			{
			temp.ziffern.push_back(*i + *j + v - 10);
			v = 1;
			}
			else
			{
				temp.ziffern.push_back(*i + *j - 10);
				v = 0;
			}
			++j;

		}
		reverse(temp.ziffern.begin(), temp.ziffern.end()); // Ziffern werden in die richtige reihenvolge gebracht
		return temp;
	}