Le polymorphisme en c++

dans C++, la distinction importante est run-time vs. compile-time binding. Ad-hoc vs paramétrique n'aide pas vraiment, comme je l'expliquerai plus tard.

|----------------------+--------------|
| Form                 | Resolved at  |
|----------------------+--------------|
| function overloading | compile-time |
| operator overloading | compile-time |
| templates            | compile-time |
| virtual methods      | run-time     |
|----------------------+--------------|

Note - polymorphisme de l'exécution peut encore être résolu à la compilation, mais c'est juste de l'optimisation. Le besoin de soutenir efficacement la résolution de l'exécution du temps, et la négociation contre d'autres questions, fait partie de ce qui a conduit à des fonctions virtuelles étant ce qu'ils sont. Et c'est vraiment la clé pour toutes les formes de polymorphisme en C++, chaque provient de différents ensembles de compromis faite dans un contexte différent.

la surcharge de la fonction et la surcharge de l'opérateur sont la même chose dans tous les sens du terme. Les noms et la syntaxe pour les utiliser n'affectent pas le polymorphisme.

vous permettent de spécifier beaucoup de surcharges de fonctions à la fois.

il y a un autre ensemble de noms pour la même idée de temps de résolution...

|---------------+--------------|
| early binding | compile-time |
| late binding  | run-time     |
|---------------+--------------|

ces noms sont plus associés à OOP, il est donc un peu étrange de dire qu'un modèle ou une autre fonction non-membre utilise la liaison précoce.

pour mieux comprendre la relation entre les fonctions virtuelles et la surcharge de la fonction, il est également utile de comprendre la différence entre" expédition simple "et"expédition multiple". L'idée peut être comprise comme une progression...

• tout d'abord, il ya des fonctions monomorphiques. Le la mise en œuvre de la fonction est identifiée de façon unique par le nom de la fonction. Aucun des paramètres spéciaux.
• il n'y a donc qu'une seule expédition. L'un des paramètres est considéré comme spécial, et utilisé (avec le nom) pour identifier la mise en œuvre d'utilisation. Dans OOP, nous avons tendance à considérer ce paramètre comme "l'objet", à le lister avant le nom de la fonction, etc.
• ensuite, il y a une expédition multiple. Tous les paramètres contribuent à identifier ce qui suit: la mise en œuvre d'utilisation. Donc, une fois de plus, aucun des paramètres doit être spécial.

il y a évidemment plus à OOP qu'une excuse pour désigner un paramètre comme spécial, mais c'est une partie de celui-ci. Et pour revenir à ce que j'ai dit à propos des compromis-expédition simple est assez facile à faire efficacement (l'implémentation habituelle est appelée "tables virtuelles"). L'expédition Multiple est plus embarrassante, non seulement en termes d'efficacité, mais aussi pour séparer compilation. Si vous êtes curieux, vous pourriez chercher "le problème d'expression".

tout comme il est un peu étrange d'utiliser le terme" early binding "pour les fonctions non-membres, il est un peu étrange d'utiliser les Termes" single dispatch "et" multiple dispatch " où le polymorphisme est résolu au moment de la compilation. Généralement, C++ est considéré comme n'ayant pas d'expédition multiple, ce qui est considéré comme un type particulier de résolution de l'exécution. Toutefois, la surcharge de la fonction peut être considérée comme une expédition multiple effectuée à au moment de la compilation.

pour en revenir au polymorphisme paramétrique par opposition au polymorphisme ad-hoc, ces termes sont plus populaires dans la programmation fonctionnelle, et ils ne fonctionnent pas tout à fait en C++. De même...

polymorphisme paramétrique signifie que vous avez des types comme paramètres, et le même code exact est utilisé quel que soit le type que vous utilisez pour ces paramètres.

polymorphisme Ad-hoc est ad-hoc dans le sens où vous fournissez un code différent selon le des types particuliers.

Surcharge et les fonctions virtuelles sont deux exemples d'ad-hoc polymorphisme.

encore une fois, il y a des synonymes...

|------------+---------------|
| parametric | unconstrained |
| ad-hoc     | constrained   |
|------------+---------------|

sauf que ce ne sont pas tout à fait des synonymes, bien qu'ils soient généralement traités comme s'ils l'étaient, et c'est là que la confusion est susceptible d'apparaître en C++.

le raisonnement derrière le fait de traiter ces synonymes est qu'en limitant le polymorphisme à des les classes de types, il devient possible d'utiliser des opérations spécifiques à ces classes de types. Le mot "classes" ici peut être interprété dans le sens OOP, mais se réfère vraiment juste à (habituellement nommé) ensembles de types qui partagent certaines opérations.

ainsi, le polymorphisme paramétrique est généralement considéré (au moins par défaut) comme un polymorphisme non limité. Parce que le même code est utilisé indépendamment des paramètres de type, les seules opérations supportables sont celles qui fonctionnent pour tous type. En laissant l'ensemble des types sans contrainte, vous limiter sévèrement l'ensemble des opérations que vous pouvez appliquer à ces types.

dans par exemple Haskell, vous pouvez avoir...

myfunc1 :: Bool -> a -> a -> a
myfunc1 c x y = if c then x else y

le a voici un type polymorphe non limité. Ça pourrait être n'importe quoi, donc on ne peut pas faire grand-chose avec ce genre de valeurs.

myfunc2 :: Num a => a -> a
myfunc2 x = x + 3

ici, a est contraint d'être un membre de la classe Num types ça ressemble à des chiffres. Cette contrainte vous permet de faire des choses en nombre avec ces valeurs, comme les ajouter. Même le 3 est polymorphique - type inférence se rend compte que vous voulez dire le 3 de type a .

je pense que c'est un polymorphisme paramétrique limité. Il n'y a qu'une mise en œuvre, mais elle ne peut être appliquée que dans des cas limités. L'aspect ad hoc est le choix de + et 3 à utiliser. Chaque "instance" de Num a sa propre mise en œuvre distincte de ceux-ci. Donc même dans Haskell "paramétrique" et "sans contrainte" ne sont pas vraiment synonymes - ne me blâmez pas, ce n'est pas ma faute!

en C++, la surcharge et les fonctions virtuelles sont des polymorphismes ad hoc. La définition du polymorphisme ad hoc ne se soucie pas de savoir si l'implémentation est sélectionnée à l'exécution ou à la compilation.

C++ devient très proche du polymorphisme paramétrique avec des modèles si chaque le paramètre template a le type typename . Il y a des paramètres de type, et il n'y a qu'une seule implémentation, peu importe les types utilisés. Toutefois, la règle "échec de Substitution N'est pas une erreur" signifie que des contraintes implicites découlent de l'utilisation d'opérations dans le modèle. D'autres complications comprennent la spécialisation des modèles pour la fourniture d'autres modèles - différentes mises en œuvre (ad hoc).

donc D'une certaine façon C++ a un polymorphisme paramétrique, mais il est implicitement limité et pourrait être supplanté par des alternatives ad hoc-c'est - à-dire que cette classification ne fonctionne pas vraiment pour C++.

en ce qui concerne le polymorphisme ad hoc, il s'agit de la surcharge de fonction ou de la surcharge de l'opérateur. Voir ici:

http://en.wikipedia.org/wiki/Ad-hoc_polymorphism

en ce qui concerne le polymorphisme paramétrique, les fonctions de gabarit peuvent également être comptées parce qu'elles ne prennent pas nécessairement en compte des paramètres de types fixes. Par exemple, une fonction peut trier un tableau d'entiers et elle peut aussi trier un tableau de chaînes, etc.

http://en.wikipedia.org/wiki/Parametric_polymorphism

cela peut ne pas être d'aucune aide, mais je l'ai fait pour présenter mes amis à la programmation en donnant des fonctions définies, comme START , et END pour la fonction principale de sorte que ce n'était pas trop intimidant (ils ont seulement utilisé le main.cpp ). Il contient des classes et des structures polymorphiques, des gabarits, des vecteurs, des tableaux, des directives de préprocesseur, de l'amitié, des opérateurs et des pointeurs (tout ce que vous devriez probablement savoir avant de tenter le polymorphisme):

Note: Il n'est pas terminé, mais vous pouvez obtenir l'idée

principal.cpp

#include "main.h"
#define ON_ERROR_CLEAR_SCREEN false
START
    Library MyLibrary;
    Book MyBook("My Book", "Me");
    MyBook.Summarize();
    MyBook += "Hello World";
    MyBook += "HI";
    MyBook.EditAuthor("Joe");
    MyBook.EditName("Hello Book");
    MyBook.Summarize();
    FixedBookCollection<FairyTale> FBooks("Fairytale Books");
    FairyTale MyTale("Tale", "Joe");
    FBooks += MyTale;
    BookCollection E("E");
    MyLibrary += E;
    MyLibrary += FBooks;
    MyLibrary.Summarize();
    MyLibrary -= FBooks;
    MyLibrary.Summarize();
    FixedSizeBookCollection<5> Collection("My Fixed Size Collection");
    /* Extension Work */ Book* Duplicate = MyLibrary.DuplicateBook(&MyBook);
    /* Extension Work */ Duplicate->Summarize();
END

principal.h

#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <type_traits>
#include <array>
#ifndef __cplusplus
#error Not C++
#endif
#define START int main(void)try{
#define END GET_ENTER_EXIT return(0);}catch(const std::exception& e){if(ON_ERROR_CLEAR_SCREEN){system("cls");}std::cerr << "Error: " << e.what() << std::endl; GET_ENTER_EXIT return (1);}
#define GET_ENTER_EXIT std::cout << "Press enter to exit" << std::endl; getchar();
class Book;
class Library;
typedef std::vector<const Book*> Books;
bool sContains(const std::string s, const char c){
    return (s.find(c) != std::string::npos);
}
bool approve(std::string s){
    return (!sContains(s, '#') && !sContains(s, '%') && !sContains(s, '~'));
}
template <class C> bool isBook(){
    return (typeid(C) == typeid(Book) || std::is_base_of<Book, C>());
}
template<class ClassToDuplicate> class DuplicatableClass{ 
public:
    ClassToDuplicate* Duplicate(ClassToDuplicate ToDuplicate){
        return new ClassToDuplicate(ToDuplicate);
    }
};
class Book : private DuplicatableClass<Book>{
friend class Library;
friend struct BookCollection;
public:
    Book(const char* Name, const char* Author) : name_(Name), author_(Author){}
    void operator+=(const char* Page){
        pages_.push_back(Page);
    }
    void EditAuthor(const char* AuthorName){
        if(approve(AuthorName)){
            author_ = AuthorName;
        }
        else{
            std::ostringstream errorMessage;
            errorMessage << "The author of the book " << name_ << " could not be changed as it was not approved";
            throw std::exception(errorMessage.str().c_str());
        }
    }
    void EditName(const char* Name){
        if(approve(Name)){
            name_ = Name;
        }
        else{
            std::ostringstream errorMessage;
            errorMessage << "The name of the book " << name_ << " could not be changed as it was not approved";
            throw std::exception(errorMessage.str().c_str());
        }
    }
    virtual void Summarize(){
        std::cout << "Book called " << name_ << "; written by " << author_ << ". Contains "
            << pages_.size() << ((pages_.size() == 1) ? " page:" : ((pages_.size() > 0) ? " pages:" : " pages")) << std::endl;
        if(pages_.size() > 0){
            ListPages(std::cout);
        }
    }
private:
    std::vector<const char*> pages_;
    const char* name_;
    const char* author_;
    void ListPages(std::ostream& output){
        for(int i = 0; i < pages_.size(); ++i){
            output << pages_[i] << std::endl;
        }
    }
};
class FairyTale : public Book{
public:
    FairyTale(const char* Name, const char* Author) : Book(Name, Author){}
};
struct BookCollection{
friend class Library;
    BookCollection(const char* Name) : name_(Name){}
    virtual void operator+=(const Book& Book)try{
        Collection.push_back(&Book); 
    }catch(const std::exception& e){
        std::ostringstream errorMessage;
        errorMessage << e.what() << " - on line (approx.) " << (__LINE__ -3);
        throw std::exception(errorMessage.str().c_str());
    }
    virtual void operator-=(const Book& Book){
        for(int i = 0; i < Collection.size(); ++i){
            if(Collection[i] == &Book){
                Collection.erase(Collection.begin() + i);
                return;
            }
        }
        std::ostringstream errorMessage;
        errorMessage << "The Book " << Book.name_ << " was not found, and therefore cannot be erased";
        throw std::exception(errorMessage.str().c_str());
    }
private:
    const char* name_;
    Books Collection;
};
template<class FixedType> struct FixedBookCollection : public BookCollection{
    FixedBookCollection(const char* Name) : BookCollection(Name){
        if(!isBook<FixedType>()){
            std::ostringstream errorMessage;
            errorMessage << "The type " << typeid(FixedType).name() << " cannot be initialized as a FixedBookCollection";
            throw std::exception(errorMessage.str().c_str());
            delete this;
        }
    }
    void operator+=(const FixedType& Book)try{
        Collection.push_back(&Book); 
    }catch(const std::exception& e){
        std::ostringstream errorMessage;
        errorMessage << e.what() << " - on line (approx.) " << (__LINE__ -3);
        throw std::exception(errorMessage.str().c_str());
    }
    void operator-=(const FixedType& Book){
        for(int i = 0; i < Collection.size(); ++i){
            if(Collection[i] == &Book){
                Collection.erase(Collection.begin() + i);
                return;
            }
        }
        std::ostringstream errorMessage;
        errorMessage << "The Book " << Book.name_ << " was not found, and therefore cannot be erased";
        throw std::exception(errorMessage.str().c_str());
    }
private:
    std::vector<const FixedType*> Collection;
};
template<size_t Size> struct FixedSizeBookCollection : private std::array<const Book*, Size>{
    FixedSizeBookCollection(const char* Name) : name_(Name){ if(Size < 1){ throw std::exception("A fixed size book collection cannot be smaller than 1"); currentPos = 0; } }
    void operator+=(const Book& Book)try{
        if(currentPos + 1 > Size){
            std::ostringstream errorMessage;
            errorMessage << "The FixedSizeBookCollection " << name_ << "'s size capacity has been overfilled";
            throw std::exception(errorMessage.str().c_str());
        }
        this->at(currentPos++) = &Book;
    }catch(const std::exception& e){
        std::ostringstream errorMessage;
        errorMessage << e.what() << " - on line (approx.) " << (__LINE__ -3);
        throw std::exception(errorMessage.str().c_str());
    }
private:
    const char* name_;
    int currentPos;
};
class Library : private std::vector<const BookCollection*>{
public:
    void operator+=(const BookCollection& Collection){
        for(int i = 0; i < size(); ++i){
            if((*this)[i] == &Collection){
                std::ostringstream errorMessage;
                errorMessage << "The BookCollection " << Collection.name_ << " was already in the library, and therefore cannot be added";
                throw std::exception(errorMessage.str().c_str());
            }
        }
        push_back(&Collection);
    }
    void operator-=(const BookCollection& Collection){
        for(int i = 0; i < size(); ++i){
            if((*this)[i] == &Collection){
                erase(begin() + i);
                return;
            }
        }
        std::ostringstream errorMessage;
        errorMessage << "The BookCollection " << Collection.name_ << " was not found, and therefore cannot be erased";
        throw std::exception(errorMessage.str().c_str());
    }
    Book* DuplicateBook(Book* Book)const{
        return (Book->Duplicate(*Book));
    }
    void Summarize(){
        std::cout << "Library, containing " << size() << ((size() == 1) ? " book collection:" : ((size() > 0) ? " book collections:" : " book collections")) << std::endl;
        if(size() > 0){
            for(int i = 0; i < size(); ++i){
                std::cout << (*this)[i]->name_ << std::endl;
            }
        }
    }
};

voici un exemple de base utilisant les classes polymorphiques

#include <iostream>

class Animal{
public:
   Animal(const char* Name) : name_(Name){/* Add any method you would like to perform here*/
    virtual void Speak(){
        std::cout << "I am an animal called " << name_ << std::endl;
    }
    const char* name_;
};

class Dog : public Animal{
public:
    Dog(const char* Name) : Animal(Name) {/*...*/}
    void Speak(){
        std::cout << "I am a dog called " << name_ << std::endl;
    }
};

int main(void){
    Animal Bob("Bob");
    Dog Steve("Steve");
    Bob.Speak();
    Steve.Speak();
    //return (0);
}

polymorphisme signifie plusieurs formes en tant que telles il est utilisé pour un opérateur d'agir différemment dans différentes instances. Le polymorphisme est utilisé pour mettre en œuvre l'héritage. Par exemple, nous avons défini un dessin fn () pour une forme de classe alors le dessin FN peut être mis en œuvre pour dessiner des cercles, des boîtes, des triangles et d'autres formes. (qui sont des objets de la forme de la classe)

si quelqu'un dit coupez à ces gens

The Surgeon
The Hair Stylist
The Actor

que va-t-il se passer?

The Surgeon would begin to make an incision.
The Hair Stylist would begin to cut someone's hair.
The Actor would abruptly stop acting out of the current scene, awaiting directorial guidance.

la représentation ci-dessus montre ce qu'est le polymorphisme (même nom, comportement différent) en OOP.

si vous allez à une entrevue et que l'intervieweur vous demande de donner/montrer un exemple en direct de polymorphisme dans la même salle où nous sommes assis, dites -

Réponse Portes / Fenêtres

Vous Vous Demandez Comment?

par la Porte / Fenêtre - une personne peut venir, l'air peut venir, la lumière peut venir, la pluie peut venir, etc.

c'est à dire Une forme de comportement différent(Polymorphisme).

pour mieux le comprendre et d'une manière simple j'ai utilisé l'exemple ci-dessus.. Si vous avez besoin de référence pour le code, suivez les réponses ci-dessus.