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

...

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)

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

Dieses Posting wurde automatisch erzeugt.

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.

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

Folgendes geht dann aber nicht mehr:

FLO f;
DOU d;

f = d;

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