Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Problem: Konstruktor für Konversion & abgeleitete Klasse

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
07.07.2007, 21:27 Uhr
~SuhaG
Gast


Bitte korregiert mich, wenn ich irgendwo falsch liege:

Ich habe eine Klasse BASE und eine davon abgeleitete Klasse DERIVED.
In der Klasse BASE ist ein operator + implementiert mit Operanden dieser Klasse (BASE).

Wenn ich nun zwei Typen der Klasse DERIVED addieren will (operator +) wird dazu die geerbte operator + aus BASE genutzt.
Diese benötigt aber Operanden vom Typ BASE.

Für die Konversion habe ich in jeder Klasse einen Konstruktor mit genau einem Parameter (jeweils der anderen Klasse). Diese funktionieren auch.

Wenn ich nun aber addiere wird nachweislich nicht der Konstruktor genutzt und es gehen die Informationen aus der abgeleiteten Klasse verloren.

Wieso?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
07.07.2007, 21:48 Uhr
Blubber2063



Das ist schon mal konzeptionell ein großer Denkfehler, wenn du eine klasse BASE hast du DERIVED davon ableitest und in beiden den + Operator nutzen willst, dann machst du natürlich den + Operator virtual. Achso da es sich um die Basisklasse handelt sollte hier natürlich keine Konversion nötig sein, vorrausgesetzt der + Operator ist virtual.
Dieser Post wurde am 07.07.2007 um 22:09 Uhr von Blubber2063 editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
07.07.2007, 22:10 Uhr
~SuhaG
Gast


Erst einmal vielen Dank für die Antwort.

Müsste ich den operator + nicht nur virtual deklarieren, wenn ich in der DERIVED-Klasse wieder einen operator + realisieren, sprich explizit erneut (Für Operanden der Klasse DERIVED) implementieren möchte?

Ich möchte aber eigentlich erreichen, dass meine abgeleitete Klasse automatisch ohne Informationsverlust in die BASE-Klasse konvertiert wird um so die bereits umgesetzte operator + Funktion der BASE-Klasse nutzen zu können...
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
07.07.2007, 22:11 Uhr
Blubber2063



Also ich mag mich jetzt irren, aber ohne das die Funktion virtual ist dürftest du den + Operator der Basisklasse so gar nicht nutzen können.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
07.07.2007, 22:22 Uhr
~SuhaG
Gast


Nutzen kann ich ihn, er funktioniert auch, allerdings wird anscheinend die DERIVED-Klasse zunächst in die BASE-Klasse konvertiert ohne meinen Konstruktor zu nutzen, wodurch die Informationen aus der DERIVED-Klasse verloren geht.
Hier mal der Quellcode in Kurzform:

Code:
class URational {
   protected:
      unsigned long zaehler, nenner;
   public:
      // Konstruktor
      URational(unsigned long z = 0, unsigned long n = 1);
      // Konstruktor2
      URational(const UMixed &um);
      // Operator +
      friend URational operator + (const URational &ur1, const URational &ur2);
      (...)
};

class UMixed : public URational {
   protected:
      unsigned long intpart;
   public:
      UMixed(unsigned long ip = 0, unsigned long z = 0, unsigned long n = 1);
      UMixed(const URational &ur);
      UMixed(const UMixed &um);
};

/******************/

URational::URational(const UMixed &um)
{
   zaehler = (UMixed(um)).zaehler;
   nenner = (UMixed(um)).nenner;
}

URational operator + (const URational &ur1, const URational &ur2)
{
   URational res;
   unsigned long kgv, m1, m2, resggt;
  
   kgv = (ur1.nenner * ur2.nenner) / ggt(ur1.nenner, ur2.nenner);
   m1 = kgv / ur1.nenner;
   m2 = kgv / ur2.nenner;
  
   res.zaehler = (ur1.zaehler * m1) + (ur2.zaehler * m2);
   res.nenner = kgv;
  
   res.kuerzen();

   return res;
}

/*****************/

UMixed::UMixed(const URational &ur)
   :URational(ur)
{
   if (zaehler > nenner) {
      unsigned long rest;
      rest = zaehler % nenner;
      intpart = (zaehler - rest) / nenner;
      zaehler = rest;
   } else
      intpart = 0;
}

UMixed::UMixed(const UMixed &um)
{
   zaehler = um.zaehler + (um.intpart * um.nenner);
   nenner = um.nenner;
   intpart = 0;
}



Die explizite Konversion funktioniert...
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
07.07.2007, 22:40 Uhr
Blubber2063



Das die Konversion über den Konstruktor dir die Daten raubt ist klar, denn du erzeugst ja nur ein Objekt der Basisklasse(was an sich schon unsinnig ist), aber warum das nicht funktioniert ist mir ein Rästel an sich muss das eigentlich gehen.

Bin grad noch drauf gekommen, das liegt mit ziemlicher Sicherheit am return type, hab grad mal folgendes Beispiel erfolgreich getestet :

C++:
#include <iostream>

class Base
{
   public:
        Base(int x):v(x){};
        virtual ~Base() {}
        virtual Base operator+(Base &z){
            return v + z.v;
        }
        virtual int getval(){return v;}
    protected:
        int v;
        virtual int getv(){return v;}
};

class A : public Base
{
   public:
        A(int x):Base(x) {  }
/*        virtual Base operator+(A &z){
            return v + z.v;
        }*/

      
};

class B : public A
{
    public:
        B(int x): A(x) {}
        /*virtual Base operator+(B &z){
            return v + z.v;
        }
*/
};
int main( void )
{  
    B b(2), c(4);
    Base d = b+c;
    std::cout << d.getval() <<std::endl;
    return 0;
}


Liegt also denke ich mal bei dir auch am return Type deines + Ausdrucks.
Also wenn du hier nen anderen return type als Base haben willst wirst du wohl nen virtual class Operator+ definieren müssen und den dann überladen.

Dieser Post wurde am 07.07.2007 um 23:11 Uhr von Blubber2063 editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
08.07.2007, 11:25 Uhr
~SuhaG
Gast


Vielen Dank für die Hilfe, werde mir das jetzt mal genauer angucken...
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: