Operatorüberladung "="

**Hi,

ich habe eine Klasse in der zwei Strukturen definiert sind. Nun möchte ich den Zuweisungsoperator in der Art überladen:
**

typedef struct{
double x,y,z;
}DOU;

typedef struct{
float x,y,z;
}FLO;

Mayclass::DOU Mayclass::operator = (Mayclass::FLO B)
{Mayclass::DOU A;
A.x=B.x;A.y=B.y;A.z=B.z;
return A;
}

geht sowas?
das klappt beim mir nicht

...

CStoll

Der Zuweisungsoperator wird überladen, um der Klasse etwas zuzuweisen, in der er definiert ist - d.h. in deinem Fall für Zuweisungen von FLO nach Mayclass. Wenn du zwischen den beiden structs zuweisen willst, mußt du ihnen selber einen Zuweisungsoperator verpassen:

struct FLO;
struct DOU
{
  double x,y,z;
  DOU& operator=(const FLO&);
}
struct FLO
{
  float x,y,z;
  FLO& operator=(const DOU);
}

Mayclass::DOU& Mayclass::DOU::operator=(const Mayclass::FLO& other)
{
  x=other.x;y=other.y;z=other.z;
  return *this;
}

(und der Vollständigkeit halber solltest du auch Konvertierungs-konstruktoren bereitstellen)

C++ Forumbot

Dieser Thread wurde von Moderator/in CStoll aus dem Forum MFC (Visual C++) in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

*john 0

CStoll schrieb:

Code ...

Das gefällt mir gar nicht.

struct FLO;
struct DOU {
  double x,y,z;
  DOU ();
  DOU (FLO const&);

};
struct FLO {
  float x,y,z;
  FLO ();
  explicit FLO (DOU const&);
};

DOU::DOU (FLO const& rhs) : x(rhs.x), y(rhs.y), z(rhs.z) {}

FLO::FLO (DOU const& rhs) : x(rhs.x), y(rhs.y), z(rhs.z) {}

Zuweisungsoperatoren braucht man dann gar nicht, denn der Compiler erstellt sie für die Objekte derselben Klasse eh, und im Zweifelsfall wird konvertiert.

pumuckl

Folgendes geht dann aber nicht mehr:

FLO f;
DOU d;

f = d;

Der Compiler würde vermutlich versuchen, den implizit generierten op= von FLO zu verwenden und vorher aus d ein FLO zu machen - was nicht geht wenn die Ctoren explicit sind. Also müsste man stattdessen folgendes schreiben:

f = FLO(d);

was widerum bedeutet, dass man erst den Umwandlungs-Ctor aufruft und danach den op=. Der op= für den jeweils anderen Typen würde den einen Funktionsaufruf einsparen - aber natürlich soll man erst anfangen zu optimieren wenn einem der profiler das gesagt hat

*john 0

pumuckl schrieb:

Folgendes geht dann aber nicht mehr:
FLO f;
DOU d;

f = d;

Ja, das ist gewollt, da dabei Informationsverlust auftreten kann.

Operatorüberladung &quot;=&quot;

Operatorüberladung "="