ist es auf irgendeine Weise möglich, zwei ungleiche Klassenobjekte mit gemeinsamer Schnittmenge (Laenge und Breite) einander zuzuweisen?

struct Teil2D
{
   int Laenge;
   int Breite;
};

struct Teil3D
{
   int Laenge;
   int Breite;
   int Hoehe;
};

int main()
{
   Teil2D T2D;
   Teil3D T3D;

   T3D = T2D  // Wichtig in dieser Reihenfolge!

   return 0;
}

Wichtig ist, dass T2D, T3D zugewiesen wird. Das dabei "Hoehe" nicht zugewiesen wird ist belanglos.

struct Teil2D
{
   int Laenge;
   int Breite;
};

struct Teil3D
{
   Teil2D grundteil;
   int Hoehe;
};

class Teil2D
{
public:
	int Laenge;
	int Breite;

	Teil2D& operator = (const Teil2D& T)
	{
		Laenge = T.Laenge;
		Breite = T.Breite;
		return *this;
	}
};

class Teil3D
{
public:
	int Laenge;
	int Breite;
	int Hoehe;

	Teil3D& operator = (const Teil3D& T)
	{
		Laenge = T.Laenge;
		Breite = T.Breite;
                Hoehe = T.Hoehe;
		return *this;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	Teil2D T2D;
	Teil3D T3D;

	T3D = T2D;  // error C2679: Binärer Operator '=': 
                    //Es konnte kein Operator gefunden werden, der einen 
                    //rechtsseitigen Operanden vom Typ 'Teil2D' akzeptiert

	return 0;
}

Teil2D& operator = (const Teil3D& T) { ... }

Teil3D& operator = (const Teil2D& T) { ... }

sein.

Warum nicht gleich richtig modellieren?

Ja, so habe ich es bislang auch Implementiert. Ich würde jedoch gerne ohne "Teil" in Teil1 und Teil2 auskommen. Ist das möglich?

struct Teil
{
   int ID;

struct Teil1
{
   Teil teil;
   int  Laenge;
};

struct Teil2
{
   Teil teil;
   int  Laenge;
   int  Breite;
};

int main()
{
   Teil1 T1;
   Teil2 T2;

   T2 = T1;
}

Teil3D& operator=(const Teil2D& T)
    {
        Laenge = T.Laenge;
        Breite = T.Breite;
        Hoehe  = 0;
        return *this;
    }

So funktioniert es. Vielen Dank an icarus2 und dgdgdfg!

class Teil3D
{
public:
    int Laenge;
    int Breite;
    int Hoehe;

    Teil3D(const Teil3D& T)
      : Laenge(T.Laenge),
        Breite(T.Breite),
        Hoehe(0)
    {
    }
};

Sollte genauso funktionieren.

Lieber bietet man eine automatische Konvertierung von Teil2D zu Teil3D an:

Bist du sicher, dass du die Reihenfolge richtig hast?

void main schrieb:

Lieber bietet man eine automatische Konvertierung von Teil2D zu Teil3D an:

Bist du sicher, dass du die Reihenfolge richtig hast?

Hier eigentlich schon (es wird ein Teil3D aus Teil2D erstellt).

Aber im Konstruktor habe ich das falsche Argument, das sollte natürlich const Teil2D& T sein.

dgdgdfg schrieb:

Teil3D& operator=(const Teil2D& T)
    {
        Laenge = T.Laenge;
        Breite = T.Breite;
        Hoehe  = 0;
        return *this;
    }

So funktioniert es. Vielen Dank an icarus2 und dgdgdfg!

class Apfel{};
class Birne{};
const Apfel& operator=(const Birne& B);

im Ernst - was soll das werden?

mit Länge x Breite kannst du keine Fläche beschreiben, sondern allenfalls ein Rechteck.

Mit Grundfläche x Höhe andererseits kannst du keinen Körper beschreiben, sondern allenfalls ein Prisma.

ich würde die Klassen statt "Teil2D" und 3D eher "Rechteck" und "Quader" nennen, und ob es guter Stil ist, ein Rechteck per Zuweisung in einen Quader der Höhe 0 zu wandeln, halte ich für eher fragwürdig. Ich würde eher eine Funktion wie "Quader MakeQuader(const Rectangle&, double height)" bauen, hängt aber vom Anwendungsfall ab.

...ich würde die Klassen statt "Teil2D" und 3D eher "Rechteck" und "Quader" nennen...

Die vielleicht nicht sehr glücklich gewählten Klassenbezeichner wurden nur für den verkürzten Beispiel Code gewählt, um die Frage zu verdeutlichen. In meinem Programm gibt es keine 2D oder 3D Elemente...

{
	Teil2D T2D;
	Teil3D T3D;

	T3D = T2D;
	
	return 0;
}

Der Compiler sucht nach einer Funktion mit der Signatur:

Teil3D& operator=(Teil3D&, const Teil2D&);

oder eine Memberfunktion von Teil3D:

Teil3D& Teil3D::operator=(const Teil2D&);

oder nach einem Impliziten Konvertieroperator von Teil2D nach Teil3D. Es gibt noch ein paar mehr Möglichkeiten. Aber die lasse ich mal weg.