Metodo della classe derivata dalla classe base riferimento

Question

class Material 
{ 
public: 
void foo() 
{ 
    cout << "Class Material"; 
} 
}; 

class Unusual_Material : public Material 
{ 
public: 
void foo() 
{ 
    cout << "Class Unusual_Material"; 
} 
}; 

int main() 
{ 
Material strange = Unusual_Material(); 
strange.foo(); //outputs "Class Material" 

return 0; 
} 

Vorrei che questo risultasse nella "Classe Unusual_Material" visualizzata alla console. C'è un modo per ottenerlo? Nel mio programma ho un materiale di classe da cui derivano altri materiali più specifici. Il metodo Material :: foo() rappresenta un metodo in Materiale che è adeguato per la maggior parte dei materiali, ma occidentalmente, un altro foo() deve essere definito per un materiale con proprietà insolite.

Tutti gli oggetti nel mio programma contengono un campo Materiale. Nel caso in cui gli venga assegnato un materiale insolito, mi piacerebbe che venisse chiamato l'insolito foo.

Probabilmente questo è piuttosto facile o impossibile, ma non riesco a capirlo in alcun modo.

Grazie

Answer 1

Quello che vuoi è il polimorfismo, e per consentirle di una funzione è necessario renderlo virtual:

class Material 
{ 
public: 
    virtual void foo() // Note virtual keyword! 
    { 
     cout << "Class Material"; 
    } 
}; 

class Unusual_Material : public Material 
{ 
public: 
    void foo() // Will override foo() in the base class 
    { 
     cout << "Class Unusual_Material"; 
    } 
}; 

Inoltre, il polimorfismo funziona solo per i riferimenti e puntatori:

int main() 
{ 
    Unusual_Material unusualMaterial; 
    Material& strange = unusualMaterial; 
    strange.foo(); 
    return 0; 
} 

/* OR */ 

int main() 
{ 
    Unusual_Material unusualMaterial; 
    Material* strange = &unusualMaterial; 
    strange->foo(); 
    return 0; 
} 

Quello che hai nel tuo snippet di codice sarà slice the Unusual_Material object:

int main() 
{ 
    // Unusual_Material object will be sliced! 
    Material strange = Unusual_Material(); 
    strange.foo(); 
    return 0; 
} 

Answer 2

Ancora migliore spiegazione sarebbe ..

class Base 
{ 
public: 
void foo()  //make virtual void foo(),have derived method invoked 
{ 
    cout << "Class Base"; 
} 
}; 
class Derived: public Base 
{ 
public: 
void foo() 
{ 
    cout << "Class Derived"; 
} 
}; 
int main() 
{ 
Base base1 = Derived(); 
Base1.foo(); //outputs "Class Base" 
      // Base object, calling base method 

Base *base2 = new Derived(); 
Base2->foo(); //outputs"Class Base",Again Base object calling base method 

// But to have base object, calling Derived method, following are the ways 
// Add virtual access modifier for base foo() method. Then do as below, to //have derived method being invoked. 
// 
// Base *base2 = new Derived(); 
// Base2->foo(); //outputs "Class Derived" . 

return 0; 
}