Polymorphisme vs hérédité. Diffrence?

Question

Je ne comprends pas la diffrence entre Polymorphisme et héritage ... Ils font Litterarly la même chose ...

Exemple simple de Polymorphisme:

class shape { 
    public: 
     void setValues(int height_, int width_) { 
      height = height_, width = width_; 
     } 
    protected: 
     int height, width; 

    private: 

    }; 

    class rectangle :public shape, public ThreeDView{ 
    public: 
     int area() { 
      return(shape::height*shape::width); 
     } 
     float threeDArea() { 
      return(((shape::height*shape::width)/2)*(std::cos(Z_LENGTH))); 
     } 
    }; 

class ThreeDView{ 
public: 
    void setZLength(int value) { 
     Z_LENGTH = value; 
    } 

    int setCompact(bool ans) { 
     compact = ans; 
    } 

    float getZLength() { 
     return Z_LENGTH; 
    } 

    bool getCOMPACT() { 
     return compact; 
    } 
protected: 
    float Z_LENGTH; 
    bool compact; 

private: 
    unsigned char ZCHAR = 'Z'; 
}; 


    class triangle :public shape { 
    public: 
     int area() { 
      return((shape::height * shape::width)/2); 
     } 
    }; 

    int main(){ 
    rectangle rect2; 
     triangle trng2; 
     shape *poly = &rect2; 
     shape *poly2 = &trng2; 

     poly->setValues(2,3); 
     poly2->setValues(5,4); 
     std::cout << "AREA : " << trng1.area() << "AREA RECT : \n" <<rect1.area() << std::endl; 
    } 

exemple ci-dessus traduit à l'héritage:

class shape { 
public: 
    void setValues(int height_, int width_) { 
     height = height_, width = width_; 
    } 
protected: 
    int height, width; 

private: 

}; 

class rectangle :public shape, public ThreeDView{ 
public: 
    int area() { 
     return(shape::height*shape::width); 
    } 
    float threeDArea() { 
     return(((shape::height*shape::width)/2)*(std::cos(Z_LENGTH))); 
    } 
}; 

class triangle :public shape { 
public: 
    int area() { 
     return((shape::height * shape::width)/2); 
    } 
}; 

int main(){ 
rectangle rect2; 
triangle trng2; 

    rect2.setValues(2,3); 
    trng2.setValues(5,4); 
    std::cout << "AREA : " << trng1.area() << "AREA RECT : \n" <<rect1.area() << std::endl; 
} 

S'il vous plaît dites-moi diffrence. Honnêtement, je ne vois même pas l'utilisation du polymorphisme! Merci pour ton aide!

Answer 1

est ici une version de votre premier exemple, qui utilise en fait polymorphisme:

#include <iostream> 
#include <string> 

class shape 
{ 
public: 
    void setValues(int height_, int width_) 
    { 
     height = height_; 
     width = width_; 
    } 

    virtual int area() = 0; // This is needed for polymorphism to work 

    virtual std::string name() = 0; 

protected: 
    int height; 
    int width; 
}; 

class rectangle : public shape 
{ 
public: 
    int area() 
    { 
     return height * width; 
    } 

    std::string name() 
    { 
     return "Rectangle"; 
    } 
}; 

class triangle :public shape 
{ 
public: 
    int area() 
    { 
     return height * width/2; 
    } 

    std::string name() 
    { 
     return "Triangle"; 
    } 
}; 

void print_area(shape& poly) 
{ 
    std::cout << poly.name() << ' ' << poly.area() << '\n'; 
} 

int main() 
{ 
    rectangle rect; 
    triangle trng; 

    rect.setValues(2, 3); 
    trng.setValues(5, 4); 

    print_area(rect); 
    print_area(trng); 
} 

Le premier grand changement est que je déclare la fonction virtualarea dans la classe shape. Pour que le polymorphisme fonctionne, les fonctions doivent être déclarées dans la classe de base sous la forme virtual. L'affectation à 0 indique simplement au compilateur que c'est une fonction abstract, et que les classes enfants doivent remplacer cette fonction.

Le deuxième grand changement est que j'utilise une fonction pour imprimer la zone, une qui prend seulement une référence à la classe de base shape. Vous devez utiliser des références ou des pointeurs vers la classe de base pour que le polymrphisme fonctionne, n'utilisez pas directement les objets comme dans votre exemple.

This works as expected.