Subtyping-Polymorphie in C++

Question

Ich habe dieses Programm in C++.

ref2.h:

#ifndef REF2_H 
#define REF2_H 
#include <iostream> 
using std::cout; 
using std::endl; 

int add_int_int(int a, int b) {return (a+b);} 

class IntClass; 

class Number { 
    public: 

     //return a Number object that's the results of x+this, when x is IntClass 
     virtual Number& addInt(IntClass& x) = 0; 

     //Print the number stored in the object 
     virtual void print_number() = 0; 
    } 

class IntClass : public Number { 

    private: 
     int my_number; 

    public: 
     //Constructor 
     IntClass(int n):my_number(n) {} 

     //returns the number stored in the object 
     int get_number() {return my_number;} 

     //print the number stored in the object 
     void print_number() {cout << my_number << endl;} 

     Number& addInt(IntClass& x); 
    } 

Number& IntClass::addInt(IntClass& x) 
{ 
    int n = add_int_int(my_number, x.get_number()); 
    IntClass elem = IntClass(n); 
    IntClass &ref = elem; 
    return ref;  
} 

#endif 

test.cpp

#include "ref2.h" 
#include <iostream> 
using std::cout; 
using std::endl; 


int main() {  
    cout << "Testing subtyping polymorphism:" << endl; 
    IntClass ia(1); 
    IntClass ib(2); 
    Number& num = ia.addInt(ib);  num.print_number(); //should be: 3 
} 

ich nicht mein Fehler finden. Wenn mir jemand helfen kann?

Answer 1

Sie einen Verweis auf ein lokales Objekt zurückkehrt, die den Gültigkeitsbereich verlässt, wenn addInt() kehrt:

IntClass elem = IntClass(n); 
IntClass &ref = elem; 
return ref;  

Answer 2

Sie einen Verweis auf eine lokale Variable in addInt() zurückkehrt. Tu das nicht. Der Compiler sollte Sie davor gewarnt haben.

Answer 3

Das Konzept der Rückgabe eines Verweises auf eine Nummer ist (in diesem Fall) fehlerhaft. Stellen Sie sich eine Referenz wie einen Zeiger vor. Die Funktion IntClass :: addInt weist ein neues IntClass-Objekt auf dem Stapel zu und gibt dann einen Verweis darauf zurück.

Wenn die Funktion zurückkehrt, wird der Speicher für die IntClass freigegeben, so dass die Referenz auf Müll verweist.

Sie sollten einen Zeiger auf eine Nummer (Nummer *) zurückgeben, und Sie müssen new IntClass verwenden, um einen zu erstellen. Dann müssen Sie auch delete darauf anrufen, wenn Sie es verwenden.