Verwenden von dynamischer Umwandlung, um unterschiedliche Werte für Variable in abgeleiteter Klasse zurückzugeben

Question

Versuchen, einen Weg zu finden, meine dynamische Umwandlung zu arbeiten, aber ich bekomme Laufzeitfehler. Es springt beim Ausgeben zum else-Anweisungsblockwert (wenn es ein if-Blockwert sein soll, wird aber nicht einmal verwendet, wenn ich es innerhalb der abgeleiteten Klasse aufruft. Es zeigt also den falschen Wert an und verwendet es auch gar nicht in der . Berechnung Warum ist das Danke für die Hilfe

class Package 
{ 
protected: 
    string name_and_address = "?"; 

    double cost = 0.0; 
    double discount = 0.0; 
    double discount_rate = 0.0; 

    bool overnight_delivery = false; 
    bool insured = false; 

    string package_contents = "?"; 

    double shipcost = 0.0; 

public: 
    Package() {}; 
    ~Package() {}; 

protected: 
    virtual double calculate_cost() = 0; 

    class Video_Games {}; //defined the classes 
    class Genius_Phone {}; 
    class Sausage {}; 
    class Albums {}; 

    // here I'm trying to change "shipcost" inside each of the derived classes 
    // to their respective and appropriate dollar values. 
    // However, I am getting a runtime error wherein it will jump DIRECTLY 
    // to the else statement 50.00 value for Video_Games 
    // and not even calculate the value as 50.00. SO it's doubly useless. 
    // It just skips to the else value and doesn't even factor 
    // that into the Video_Games calculation when I try to test it. 
    virtual double shipping_cost() { 
     if (dynamic_cast<Video_Games*>(this)) 
      return 4.99; 
     else if (dynamic_cast<Genius_Phone*>(this)) 
      return 25.00; 
     else if (dynamic_cast<Sausage*>(this)) 
      return 9.00; 
     else 
     { 
      // should be assigned to class Albums, 
      // but is somehow being triggered by class Video_Games. 
      // Not sure why this is. 
      return 50.00; 
     } 
    } 
}; 

class Video_Games :public Package 
{ 
private: 
    int num_games = 0; 

public: 
    Video_Games(string location, int number_of_games, bool express, bool insurance) 
    { 
     num_games = number_of_games; 
     name_and_address = location; 
     overnight_delivery = express; 
     insured = insurance; 

     package_contents = to_string(num_games) + " Video Game(s)"; 

     cost = calculate_cost(); 
     discount = calculate_discount(); 
     shipcost = shipping_cost(); 
    } 

    ~Video_Games() {}; 

protected: 

    double calculate_cost() 
    { 
     cost = num_games * 19.99; 
     // this is where the magic should happen. 
     // shipcost here should be 4.99, but instead it's not even being used here. 
     // In fact - it's empty. I'm not sure why shipcost 
     // when set equal shipping_cost() is not returning that appropriate value. 
     // Very baffling. 
     if (overnight_delivery) { cost += shipcost; } 
     if (insured) { cost *= 1.06; } 

     return cost; 
    } 
}; 

Answer 1

Das Problem ist, wie Sie die anderen Klassen definiert haben:..

class Package 
{ 
    class Video_Games {}; //defined the classes 
    class Genius_Phone {}; 
    class Sausage {}; 
    class Albums {}; 

innen Package dies sind verschachtelte Typen, Sie haben eine definierte Klasse Package::Video_Games, die keine Basisklassen und keine Mitglieder hat. Die dynamic_cast Ausdrücke verwenden diese Typen, die nicht von Package ableiten:

 if (dynamic_cast<Video_Games*>(this)) 
      return 4.99; 

Namenssuche innerhalb der Package::shipping_cost() Funktion findet den Package::Video_Games-Typ, der die leere Klasse ohne Basisklassen oder Mitglieder. Das Objekt ist niemals dieser Typ, da Package::Video_Games nicht von Package abgeleitet ist, so dass der this Zeiger vom Typ Package* nicht auf ein Objekt vom Typ Package::Video_Games zeigen kann.

Später definieren Sie neue Typen mit den gleichen Namen, dass von Package ableiten:

class Video_Games :public Package 
{ 

Aber dies ist ein neuer Typ. Video_Games ist nicht derselbe Typ wie Package::Video_Games. Wenn Sie ein abgeleitetes Paketobjekt definieren, verwendet es diesen Typ und nicht den Typ, den der Cast verwendet. So werden deine Modelle niemals erfolgreich sein.

Sie müssen die Definitionen der verschachtelten Typen innerhalb Package und bewegen den Körper Ihrer Package::shipping_cost() Funktion außerhalb der Klasse zu entfernen, nachdem alle anderen Typen definiert wurden (so dass der Compiler hat die Definitionen dieser anderen Typen gesehen und weiß, sie sind abgeleitet von Package).

class Package 
{ 
    virtual double shipping_cost(); 
    // ... 
}; 

class Video_Games : public Package 
{ 
    // ... 
}; 

// Now you can define the virtual function: 
double Package::shipping_cost() 
{ 
    if (dynamic_cast<Video_Games*>(this)) 
    // ... 
} 

(Aber wie die Kommentare sagen, das ist eine wirklich schlechte Art und Weise ist eine polymorphe Schnittstelle zu definieren -. Es Niederlagen der ganze Zweck der virtuellen Funktionen)

Answer 2

Ironischerweise gegeben Ihren Benutzernamen, du bist fehlende Polymorphie für die korrekte Implementierung. Statt auf Typ wechseln, können Sie die virtuelle Methode aufrufen, und das wird die richtige Version abholen:

class Package { 
public: 
    virtual ~Package(); 
    virtual double shipping_cost() const; 
}; 
class Video_Games : public Package { 
public: 
    double shipping_cost() const override; 
}; 
class Genius_Phone : public Package { 
public: 
    double shipping_cost() const override; 
}; 
class Sausage : public Package { 
public: 
    double shipping_cost() const override; 
}; 

Package::~Package() {} 

double Package::shipping_cost() const 
{ 
    // Default implementation - may be overridden in subclasses 
    return 50.00; 
} 

double Video_Games::shipping_cost() const 
{ 
    return 4.99; 
} 

double Genius_Phone::shipping_cost() const 
{ 
    return 25.99; 
} 

double Sausage::shipping_cost() const 
{ 
    return 9.00; 
} 

ich auch, dass die Verwendung Gleitkommatypen für monetäre Werte, die Sie führen in Schwierigkeiten warnen sollte - eine Suche of Stack Overflow sollte Antworten finden, die erklären warum.