Le polymorphisme C comprend le polymorphisme à temps de compilation, d'exécution et de modèle. 1) Le polymorphisme à temps de compilation utilise la fonction et la surcharge de l'opérateur pour l'efficacité. 2) Le polymorphisme d'exécution utilise des fonctions virtuelles pour la flexibilité. 3) Le polymorphisme de modèle permet une programmation générique pour la réutilisabilité.

Lorsque vous plongez dans le monde de C, comprendre le polymorphisme, c'est comme déverrouiller un niveau secret dans un jeu vidéo - il ouvre une toute nouvelle dimension des possibilités de programmation. Le polymorphisme, qui signifie littéralement ?de nombreuses formes?, est une pierre angulaire de la programmation orientée objet (POO) qui permet aux objets de différents types d'être traités comme des objets d'un type de base commun. En C, le polymorphisme se manifeste de plusieurs manières fascinantes, chacune avec ses propres caprices et applications.

Explorons les différentes formes de polymorphisme en C et voyons comment elles peuvent être exercées pour créer un code plus flexible et maintenable.

Polymorphisme à temps de compilation: l'art de la surcharge

Le polymorphisme à temps de compilation, également connu sous le nom de polymorphisme statique, est comme un truc de magicien - tout est mis en place avant le début du spectacle. Cette forme de polymorphisme est réalisée grace à la surcharge de fonction et à la surcharge de l'opérateur.

La surcharge de fonction vous permet de définir plusieurs fonctions avec le même nom mais différentes listes de paramètres. C'est comme avoir un couteau à armée suisse; Vous choisissez le bon outil pour le travail au moment de la compilation.

 vide print (int x) {
    std :: cout << "Impression int:" << x << std :: endl;
}

vide imprimer (double x) {
    std :: cout << "Impression double:" << x << std :: endl;
}

int main () {
    imprimer (5); // appelle l&#39;impression (int)
    imprimer (3.14); // appelle l&#39;impression (double)
    retour 0;
}

La surcharge de l'opérateur, en revanche, vous permet de redéfinir le comportement des opérateurs pour les types définis par l'utilisateur. C'est comme enseigner à un vieux chien de nouvelles astuces, ce qui fait que vos cours personnalisés se comportent intuitivement.

 classe complexe {
publique:
    Complexe (double r, double i): réel (r), imag (i) {}

    Opérateur complexe (const complexe et autre) const {
        Return complexe (réel autre.real, imagin.imag);
    }

    void print () const {
        std :: cout << real << "" << imag << "i" << std :: endl;
    }

privé:
    Double réel, Imag;
};

int main () {
    Complexe A (1, 2), b (3, 4);
    Complexe c = ab;
    c.print (); // Sortie: 4 6i
    retour 0;
}

La beauté du polymorphisme à temps de compilation est son efficacité, car la décision de la fonction à appeler est prise au moment de la compilation. Cependant, il n'a pas la flexibilité dynamique du polymorphisme d'exécution.

Polymorphisme d'exécution: la magie des fonctions virtuelles

Le polymorphisme d'exécution, ou le polymorphisme dynamique, est comme une performance en direct où le public ne sait pas ce qui va suivre. Ceci est réalisé grace à des fonctions virtuelles et à l'héritage.

Les fonctions virtuelles permettent aux classes dérivées de remplacer le comportement des fonctions de classe de base. C'est comme une tradition familiale où chaque génération ajoute sa propre touche.

 Forme de classe {
publique:
    virtual void draw () const {
        std :: cout << "dessin une forme" << std :: endl;
    }
    virtual ~ forme () = par défaut; // Destructeur virtuel pour un nettoyage approprié
};

Cercle de classe: forme publique {
publique:
    void Draw () const Override {
        std :: cout << "Drawing a Circle" << std :: endl;
    }
};

Classe Rectangle: Forme publique {
publique:
    void Draw () const Override {
        std :: cout << "Drawing a rectangle" << std :: endl;
    }
};

int main () {
    Forme * formes [2];
    formes [0] = nouveau cercle ();
    formes [1] = nouveau rectangle ();

    pour (int i = 0; i <2; i) {
        formes [i] -> draw ();
    }

    // Nettoyer
    pour (int i = 0; i <2; i) {
        supprimer des formes [i];
    }

    retour 0;
}

La puissance du polymorphisme d'exécution réside dans sa capacité à décider à l'exécution de la fonction à appeler, en fonction du type d'objet réel. Cette flexibilité se fait au prix d'une légère surcharge de performances en raison de l'utilisation de tables virtuelles (VTables).

Polymorphisme de modèle: la puissance de la programmation générique

Le polymorphisme des modèles, souvent négligé, est comme un caméléon qui s'adapte à son environnement. Cette forme de polymorphisme est réalisée via C des modèles, vous permettant d'écrire du code générique qui fonctionne avec différents types.

 modèle <typename t>
T max (t a, t b) {
    retour (a> b)? R: B;
}

int main () {
    std :: cout << max (5, 10) << std :: endl; // Sortie: 10
    std :: cout << max (3.14, 2.71) << std :: endl; // Sortie: 3.14
    retour 0;
}

Les modèles sont incroyablement puissants pour écrire du code réutilisable, mais ils peuvent conduire à un ballonnement de code et à des temps de compilation plus longs s'ils ne sont pas utilisés judicieusement.

La danse du polymorphisme: quand utiliser quoi

Choisir la bonne forme de polymorphisme, c'est comme choisir le bon mouvement de danse pour la musique. Le polymorphisme à temps de compilation est parfait lorsque vous avez besoin d'efficacité et que l'ensemble des opérations est connu au moment de la compilation. Le polymorphisme d'exécution brille lorsque vous avez besoin de flexibilité et que le type exact d'objets est déterminé au moment de l'exécution. Le polymorphisme du modèle est votre référence pour la programmation générique et lorsque vous souhaitez écrire du code qui fonctionne avec plusieurs types sans sacrifier les performances.

Pièges et meilleures pratiques

• Polymorphisme à temps de compilation : Soyez prudent avec la surcharge de la fonction pour éviter l'ambigu?té. Assurez-vous toujours que les signatures de fonction sont suffisamment distinctes pour éviter les erreurs du compilateur.
• Polymorphisme d'exécution : utilisez des destructeurs virtuels dans les classes de base pour éviter les fuites de mémoire lors de la suppression des objets dérivés via des pointeurs de classe de base. Soyez conscient des frais généraux des appels de fonction virtuelle.
• Polymorphisme de la matrice : évitez les modèles trop complexes qui peuvent conduire à des erreurs de compilation ou à un ballonnement de code. Utilisez correctement les mots clés typename et template pour éviter de confondre le compilateur.

Dans mon voyage en tant que programmeur, j'ai constaté que la ma?trise de ces formes de polymorphisme rend non seulement votre code plus élégant mais aussi plus adaptable aux exigences changeantes. Que vous créiez un moteur de jeu haute performance ou un système de traitement des données flexible, la compréhension et l'application du polymorphisme peuvent efficacement élever vos prouesses de codage à de nouveaux sommets.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!