friend myclass operator+(const myclass& v1, const myclass& v2);

ich addiere v1 und v2 und setze den wert in erg (beispielsweise).

myclass erg, v1, v2;
erg = v1 + v2;

das funktioniert auch, aber ich habe nun das problem, dass ich im operator+ nochmal eine dritte classe anlegen muss, damit die anderen 2 erhalten bleiben. eigentlich wird diese durch den destruktor gelöscht, was ich aber mit dem kopierkonstruktor verhindere. und wie lösche ich denn die jetzt neu angelgte klasse? muss ich im operator = diese löschen oder wie?

vielen dank schon mal.

Für den "Bereich" suchst du wahrscheinlich boost::shared_* ...

erg = v1 + v2;

v1 und v2 sollten so erhalten bleiben.
und glaube, dass ich die "lösung" habe, aber wenn mir jemand ne belehrung gibt, immer gern
und zwar ist es glaube ich kein problem. wenn mich nicht alles täuscht, wird die temporäre klasse eh beim blockende gelöscht. oder irre ich mich da? also so:

myclass erg, v1, v2;
{
  erg = v1 + v2;     // temporäre wird angelgt
}                           // blockende temporäre (v1 + v2) wird gelöscht

also wenn das nicht stimmt, und es jemand weis wie ich ich es machen muss, bitte posten.
thx
pi88el

Das mit der dritten Klasse hört sich nicht so prickelnd an. Der binary op+ ist normalerweise sowieso nur ein schlichtes return foo(lhs) += rhs;

Huch? Nein, 'op+' erstellt immer eine Kopie, sonst würde die Operation a = b + c ja 'b' modifizieren -- das darf nicht sein.

Aus diesem Grund ist ja 'op+=' in der Regel auch effizienter.

/EDIT: Ups, ich glaube, ich habe den OP falsch verstanden.

const T operator+(const T& a, const T& b)

Und ihn zu einem friend machen ist überflüssig. Im Funktionsrumpf so wie es finix gezeigt hat. Das temporäre Objekt wird dann natürlich nach der geschweiften Klammer gelöscht, wenn du Glück hast und RVO eintritt, hast du fast keine Kosten verursacht ...

Wenn nicht friend wird er wohl klassenmember oder nicht? In dem Fall kriegt er doch nur ein Argument, oder irr ich mich?

Nein, man muss es nicht als Klassenmember implementieren. Die Implementierung von 'op+' sollte sowieso fast *immer* diese Form aufweisen:

T operator +(T const& a, T const& b)
{
    T ret = a;
    ret += b;
    return ret;
}

Und solch einen Code braucht keinerlei 'friend'-Zugriff.

aber wenn ich auf die internen private variablen von a und b zugreifen will, muss die methode friend sein oder nicht.

Ja, aber wieso solltest Du bei der implementierung von 'op+' auf private Variablen zugreifen sollen?

Sowas ist, soweit ich das sehe, nur dann nötig, wenn man dem Operator eine recht perverse Semantik verpasst. Die "Standardsemantik" ist genau wie von mir geschrieben und daran sollte man sich eigentlich auch immer halten.