C # est-il vraiment plus lent que dire C++?
Je m'interroge sur cette question depuis un moment maintenant.
Bien sûr, certains éléments de C # ne sont pas optimisés pour la vitesse. Par conséquent, l’utilisation de ces objets ou de modifications de langage (telles que LinQ) peut ralentir le code.
Mais si vous n'utilisez aucune de ces modifications, mais comparez simplement les mêmes morceaux de code en C # et C++ (il est facile de les traduire l'un en l'autre). Est-ce que ce sera vraiment beaucoup plus lent?
J'ai vu des comparaisons montrer que C # pouvait être encore plus rapide dans certains cas, car en théorie, le compilateur JIT devrait optimiser le code en temps réel et obtenir de meilleurs résultats:
Nous devons nous rappeler que le compilateur JIT compile le code en temps réel, mais qu'il s'agit d'un temps système unique, le même code (une fois atteint et compilé) n'a pas besoin d'être compilé à nouveau au moment de l'exécution.
Le catalogue général n’ajoute pas non plus beaucoup de surcharge, sauf si vous créez et détruisez des milliers d’objets (comme avec String au lieu de StringBuilder). Et le faire en C++ serait également coûteux.
Un autre point que je souhaite aborder est la meilleure communication entre les DLL introduites dans .Net. La plate-forme .Net communique beaucoup mieux que les DLL gérées basées sur COM.
Je ne vois aucune raison inhérente pour laquelle le langage devrait être plus lent, et je ne pense pas vraiment que C # soit plus lent que C++ (à la fois par expérience et par le manque d'une bonne explication).
Ainsi, un morceau du même code écrit en C # sera-t-il plus lent que le même code en C++?
Si oui, alors POURQUOI?
Une autre référence (qui parle un peu de ça, mais sans explication de pourquoi):
Pourquoi voudriez-vous utiliser C # si c'est plus lent que C++?
Avertissement: la question que vous avez posée est vraiment très complexe - probablement beaucoup plus que vous ne le réalisez. En conséquence, ceci est une réponse vraiment == longue.
D'un point de vue purement théorique, il existe probablement une réponse simple à cette question: rien (probablement) à propos de C # ne l'empêche réellement d'être aussi rapide que C++. Malgré la théorie, cependant, il existe certaines raisons pratiques pour lesquelles est plus lent à certaines choses dans certaines circonstances.
Je considérerai trois domaines de base des différences: les fonctionnalités de langage, l'exécution de la machine virtuelle et la récupération de place. Les deux derniers vont souvent ensemble, mais peuvent être indépendants, alors je les examinerai séparément.
Caractéristiques linguistiques
C++ met beaucoup d'emphase sur les modèles et les fonctionnalités du système de modèles qui sont en grande partie conçues pour permettre autant que possible d'être effectuées au moment de la compilation, donc du point de vue du programme, elles sont "statiques". La méta-programmation de modèles permet d'effectuer des calculs complètement arbitraires au moment de la compilation (c'est-à-dire que le système de modèles est complet). En tant que tel, pratiquement tout ce qui ne dépend pas de l'entrée de l'utilisateur peut être calculé lors de la compilation, il est donc simplement constant au moment de l'exécution. Cependant, les entrées peuvent inclure des informations telles que les informations de type. Par conséquent, une grande partie de ce que vous feriez via une réflexion lors de l'exécution en C # est normalement effectuée lors de la compilation via une métaprogrammation de modèle en C++. Il existe toutefois un compromis entre vitesse d'exécution et polyvalence: ce que les modèles peuvent faire, ils le font de manière statique, mais ils ne peuvent tout simplement pas faire tout ce que la réflexion peut faire.
Les différences de caractéristiques langagières signifient que presque toute tentative de comparaison des deux langages simplement en translittérant du C # en C++ (ou inversement) est susceptible de produire des résultats quelque part entre dénué de sens et trompeur (il en serait de même pour la plupart des autres paires de langages). ainsi que). Le simple fait est que, pour quelque chose de plus grand que quelques lignes de code, presque personne n’est susceptible d’utiliser les langues de la même manière (ou assez près de la même manière) qu’une telle comparaison ne donne aucune indication sur la manière dont ces langues travailler dans la vraie vie.
Machine virtuelle
Comme presque toute machine virtuelle raisonnablement moderne, Microsoft pour .NET peut et va faire une compilation JIT (aka "dynamique"). Cela représente cependant un certain nombre de compromis.
L’optimisation du code (comme la plupart des autres problèmes d’optimisation) est essentiellement un problème NP-complet. Pour un programme ou un programme vraiment trivial, vous êtes quasiment assuré que vous n'optimiserez pas vraiment le résultat (c.-à-d. Que vous ne trouverez pas l'optimum véritable) - l'optimiseur créera simplement le code mieux qu'auparavant. Cependant, quelques optimisations bien connues prennent beaucoup de temps (et souvent de mémoire) à exécuter. Avec un compilateur JIT, l'utilisateur attend pendant l'exécution du compilateur. La plupart des techniques d'optimisation plus coûteuses sont exclues. La compilation statique présente deux avantages: tout d'abord, si elle est lente (par exemple, la construction d'un système volumineux), elle est généralement effectuée sur un serveur, et nobody l'attend. Deuxièmement, un exécutable peut être généré une fois , et utilisé plusieurs fois par de nombreuses personnes. Le premier minimise le coût de l'optimisation; la seconde amortit le coût beaucoup plus petit par rapport à un nombre beaucoup plus grand d'exécutions.
Comme mentionné dans la question initiale (et dans de nombreux autres sites Web), la compilation JIT a la possibilité de mieux connaître l'environnement cible, ce qui devrait (au moins théoriquement) contrebalancer cet avantage. Il ne fait aucun doute que ce facteur peut compenser au moins une partie des inconvénients de la compilation statique. Pour quelques types de code et d’environnements cibles assez spécifiques, il peut même plus que les avantages de la compilation statique, parfois même de façon spectaculaire. Au moins dans mes tests et mon expérience, cependant, c'est assez inhabituel. Les optimisations dépendantes de la cible semblent généralement ne faire que de petites différences, ou ne peuvent être appliquées (automatiquement, de toute façon) qu'à des types de problèmes assez spécifiques. Cela se produirait évidemment si vous exécutiez un programme relativement ancien sur une machine moderne. Un ancien programme écrit en C++ aurait probablement été compilé en code 32 bits et continuerait à utiliser du code 32 bits même sur un processeur 64 bits moderne. Un programme écrit en C # aurait été compilé en code octet, que le VM compilerait ensuite en code machine 64 bits. Si ce programme tirait un avantage substantiel de son exécution en code 64 bits, cela pourrait conférer un avantage substantiel. Pendant une courte période, alors que les processeurs 64 bits étaient relativement nouveaux, cela s'est produit assez souvent. Le code récent susceptible de bénéficier d'un processeur 64 bits sera généralement disponible compilé statiquement en code 64 bits.
L'utilisation d'un VM peut également améliorer l'utilisation du cache. Les instructions pour un VM sont souvent plus compactes que les instructions de l'ordinateur natif. Un plus grand nombre d’entre eux peut s’intégrer dans une quantité donnée de mémoire cache, ce qui vous donne une meilleure chance que le code soit dans le cache en cas de besoin. Cela peut aider à garder l'exécution interprétée du code VM plus compétitive (en termes de vitesse) que la plupart des gens ne le pensaient initialement - vous pouvez exécuter un lot d'instructions sur un processeur moderne dans le temps pris par one cache miss.
Il convient également de mentionner que ce facteur n'est pas nécessairement == différent entre les deux. Rien n'empêche (par exemple) un compilateur C++ de produire une sortie destinée à être exécutée sur une machine virtuelle (avec ou sans JIT). En fait, C++/CLI de Microsoft est presque que - un compilateur C++ (presque) conforme (quoique, avec de nombreuses extensions) produisant une sortie destinée à être exécutée sur une machine virtuelle. .
L'inverse est également vrai: Microsoft a maintenant .NET Native, qui compile le code C # (ou VB.NET) en un exécutable natif. Cela donne des performances qui ressemblent généralement beaucoup plus à C++, mais conserve les fonctionnalités de C #/VB (par exemple, C # compilé en code natif supporte toujours la réflexion). Si vous utilisez un code C # à haute performance, cela peut être utile.
Garbage Collection
D'après ce que j'ai vu, je dirais que le ramassage des ordures est le plus mal compris de ces trois facteurs. Juste pour un exemple évident, la question ici mentionne: "GC n’ajoute pas non plus beaucoup de frais généraux, sauf si vous créez et détruisez des milliers d’objets [...]". En réalité, si vous créez et détruisez des milliers d'objets, la surcharge de la récupération de place sera généralement assez faible. .NET utilise un nettoyeur de génération, qui est une variété de collecteur de copie. Le ramasse-miettes fonctionne en partant des "lieux" (par exemple, des registres et de la pile d'exécution) que les pointeurs/références sont connus accessibles. Il "chasse" ensuite les pointeurs sur les objets alloués sur le tas. Il examine ces objets à la recherche d'autres pointeurs/références, jusqu'à ce qu'ils les aient tous suivis jusqu'aux extrémités des chaînes et aient trouvé tous les objets qui sont (au moins potentiellement) accessibles. Dans l’étape suivante, il utilise tous les objets utilisés (ou au moins peut être ), puis compacte le segment en le copiant dans un bloc contigu à la fois. fin de la mémoire gérée dans le tas. Le reste de la mémoire est alors libre (les finaliseurs modulo doivent être exécutés, mais au moins dans du code bien écrit, ils sont suffisamment rares pour que je les ignore pour le moment).
Cela signifie que si vous créez et détruisez == beaucoup d'objets, la récupération de place ajoute très peu de temps système. Le temps pris par un cycle de récupération de place dépend presque entièrement du nombre d'objets créés mais not détruits. La principale conséquence de la création et de la destruction rapides d’objets est simplement que le CPG doit fonctionner plus souvent, mais chaque cycle sera toujours rapide. Si vous créez des objets et que ne pas les détruisez, le CPG s'exécutera plus souvent et chaque cycle sera considérablement plus lent passe plus de temps à chasser les pointeurs sur des objets potentiellement vivants, et , il passe plus de temps à copier des objets toujours en cours d'utilisation.
Pour lutter contre cela, le nettoyage de génération repose sur l'hypothèse que les objets qui ont sont restés "en vie" pendant un certain temps sont susceptibles de rester en vie pendant encore un certain temps. Sur cette base, il existe un système dans lequel les objets qui survivent à un certain nombre de cycles de ramassage des ordures sont "conservés", et le ramasse-miettes commence simplement à supposer qu'ils sont toujours utilisés. Ainsi, au lieu de les copier à chaque cycle, il laisse simplement eux seuls. Il s'agit souvent d'une hypothèse valable selon laquelle le nettoyage de génération génère généralement des frais généraux considérablement inférieurs à ceux de la plupart des autres formes de GC.
La gestion de la mémoire "manuelle" est souvent tout aussi mal comprise. À titre d'exemple, de nombreuses tentatives de comparaison supposent que toute la gestion de la mémoire manuelle suit également un modèle spécifique (par exemple, l'allocation optimale). C’est souvent très peu (voire pas du tout) plus proche de la réalité que la croyance de nombreux peuples sur le ramassage des ordures (par exemple, l’hypothèse répandue selon laquelle il est normalement fait en utilisant le comptage des références).
Compte tenu de la diversité des stratégies pour la récupération de place et la gestion manuelle de la mémoire, il est assez difficile de comparer les deux en termes de vitesse globale. Tenter de comparer la vitesse d'allocation et/ou de libération de la mémoire (en tant que telle) est quasiment garanti de produire des résultats dénués de sens au mieux, et trompeurs au pire.
Sujet Bonus: Benchmarks
Etant donné que bon nombre de blogs, sites Web, articles de magazines, etc., prétendent fournir des preuves "objectives" dans un sens ou dans l'autre, je vais également mettre une valeur de deux cents sur ce sujet.
La plupart de ces points de repère sont un peu comme des adolescents qui décident de faire la course avec leur voiture, et quiconque gagne peut garder les deux voitures. Les sites Web diffèrent toutefois de façon cruciale: le type qui publie la référence peut conduire les deux voitures. Par une étrange chance, sa voiture l'emporte toujours et tous les autres doivent se contenter de "croyez-moi, j'étais vraiment == conduire votre voiture aussi vite que possible".
Il est facile d'écrire un mauvais repère qui produit des résultats qui ne signifient presque rien. Presque tous ceux qui possèdent les compétences nécessaires pour concevoir un point de repère produisant quelque chose de significatif, ont également la compétence pour en produire un qui donnera les résultats qu’il a déterminés. En fait, il est probablement facile == d'écrire du code pour produire un résultat spécifique par rapport à un code qui produira réellement des résultats significatifs.
Comme l'a dit mon ami James Kanze, "ne faites jamais confiance à un critère de référence que vous ne vous êtes pas faussé."
Conclusion
Il n'y a pas de réponse simple. Je suis raisonnablement sûr que je pourrais lancer une pièce pour choisir le gagnant, puis choisir un nombre compris entre (par exemple) 1 et 20 pour le pourcentage de gain, et écrire un code qui ressemblerait à un repère raisonnable et juste, et produit cette omission (au moins sur un processeur cible - un processeur différent peut changer le pourcentage un peu).
Comme d'autres l'ont souligné, pour most , la vitesse est presque sans importance. Le corollaire à cela (qui est beaucoup plus souvent ignoré) est que dans le petit code où la vitesse importe, il importe généralement de lot . Au moins dans mon expérience, pour le code où cela compte vraiment, C++ est presque toujours le gagnant. Il existe certes des facteurs favorables au C #, mais en pratique, ils semblent l'emporter sur ceux qui favorisent le C++. Vous pouvez certainement trouver des points de repère indiquant le résultat de votre choix, mais lorsque vous écrivez du code réel, vous pouvez presque toujours le rendre plus rapide en C++ qu'en C #. Cela peut prendre (ou non) plus de compétences et/ou d’efforts pour écrire, mais c’est pratiquement toujours possible.
Parce que vous n’avez pas toujours besoin d’utiliser le langage "le plus rapide" (et j’utilise celui-ci vaguement)? Je ne vais pas au volant d'une Ferrari simplement parce que c'est plus rapide ...
C++ a toujours un Edge pour la performance. Avec C #, je n’arrive pas à gérer la mémoire et j’ai littéralement des tonnes de ressources à ma disposition pour faire mon travail.
Ce dont vous avez besoin de vous interroger, c'est de savoir lequel vous fait gagner du temps. Les machines sont incroyablement puissantes maintenant et la majeure partie de votre code doit être écrit dans un langage qui vous permette d'obtenir le maximum de valeur en un minimum de temps.
Si un traitement de base prend beaucoup trop de temps en C #, vous pouvez alors créer un C++ et y interopérer avec C #.
Arrêtez de penser à la performance de votre code. Commencez à créer de la valeur.
Aux alentours de 2005, deux experts de la performance des États membres des deux côtés de la clôture native/gérée ont tenté de répondre à la même question. Leur méthode et leur processus sont toujours fascinants et les conclusions sont encore valables aujourd'hui - et je ne connais pas de meilleure tentative pour donner une réponse éclairée. Ils ont noté qu'une discussion sur les {raisons potentielles} pour les différences de performances est hypothétique et futile, et qu'une vraie discussion doit avoir un certain {base empirique} pour l'impact réel de ces différences.
Ainsi, les Vieux Nouveau Raymond Chen et Rico Mariani fixent les règles pour une compétition amicale. Un dictionnaire chinois/anglais a été choisi comme contexte d'application de jouet: suffisamment simple pour être codé comme un projet parallèle hobby, mais suffisamment complexe pour démontrer des modèles d'utilisation non triviaux des données. Les règles étaient simples: Raymond a codé une implémentation simple en C++, Rico l'a transférée en C # ligne par ligne, sans aucune sophistication, et les deux implémentations ont exécuté un test de performance. Ensuite, plusieurs itérations d'optimisations se sont ensuivies.
Les détails complets sont ici: 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 .
Ce dialogue de titans est exceptionnellement éducatif et je recommande vivement à tous de plonger - mais si vous manquez de temps ou de patience, Jeff Atwood a bien résumé les lignes du bas :
Finalement, C++ était 2x plus rapide - mais initialement, il était 13x plus lent.
Comme Rico résume :
Ai-je honte de ma défaite écrasante? À peine. Le code managé obtenu un très bon résultat pour presque aucun effort. Pour vaincre le version gérée, Raymond devait:
Écrire son propre fichier/io stuff
Écrire sa propre classe de cordes
Écrire son propre allocateur
Écrire sa propre cartographie internationale
Bien sûr, il a utilisé les bibliothèques de niveau inférieur disponibles pour cela, mais c'est encore beaucoup de travail. Pouvez-vous appeler ce qui reste une STL programme? Je ne pense pas.
C’est mon expérience encore, 11 ans et qui sait combien de versions C #/C++ plus tard.
Ce n'est pas une coïncidence, bien sûr, car ces deux langues atteignent de manière spectaculaire leurs objectifs de conception très différents. C # veut être utilisé là où le coût de développement est la considération principale (toujours la majorité des logiciels), et C++ se distingue par le fait que vous ne réduisez pas vos dépenses pour tirer le maximum de votre machine: jeux, algo-trading, data centres, etc.
C # est plus rapide que C++. Plus rapide à écrire. Pour les temps d'exécution, rien ne vaut un profileur.
Mais C # ne possède pas autant de bibliothèques que C++ peut s’interfacer facilement.
Et C # dépend fortement des fenêtres ...
Une meilleure façon de voir tout est plus lent que le C/C++, car cela fait abstraction au lieu de suivre le paradigme du bâton et de la boue. C'est ce qu'on appelle la programmation système pour une raison, vous programmez contre le grain ou le métal nu. Cela vous garantit également une vitesse que vous ne pouvez pas atteindre avec d'autres langages tels que C # ou Java. Mais hélas, les racines C ont toutes pour but de faire les choses à la dure, vous allez donc principalement écrire plus de code et passer plus de temps à le déboguer.
C est également sensible à la casse, les objets en C++ suivent également des ensembles de règles stricts. Exemple: un cornet de crème glacée pourpre peut ne pas être identique à un cornet de crème glacée bleue. Bien qu'ils puissent être des cônes, ils n'appartiennent pas nécessairement à la famille des cônes et si vous oubliez de définir quel cône est votre problème Ainsi, les propriétés de la crème glacée peuvent être ou non des clones. Maintenant, l’argument de la vitesse, C/C++ utilise l’approche pile et tas, c’est là que le métal nu obtient son métal.
Avec la bibliothèque boost, vous pouvez atteindre des vitesses incroyables. Malheureusement, la plupart des studios de jeux s’en tiennent à la bibliothèque standard. L'autre raison à cela pourrait être que les logiciels écrits en C/C++ ont tendance à avoir une taille de fichier énorme, car il s'agit d'une énorme collection de fichiers au lieu d'un fichier unique. Notez également que tous les systèmes d’exploitation sont écrits en C, alors généralement pourquoi devons-nous nous demander ce qui pourrait être plus rapide?!
De plus, la mise en cache n’est pas plus rapide que la gestion de la mémoire pure, désolée, mais cela ne se produit pas. La mémoire est quelque chose de physique, la mise en cache est quelque chose que le logiciel fait pour gagner en performance. On pourrait aussi penser que sans mémoire physique, la mise en cache n'existerait tout simplement pas. Cela n'annule pas le fait que la mémoire doit être gérée à un niveau, qu'il soit automatisé ou manuel.
En passant, les applications critiques du point de vue temporel ne sont pas codées en C # ou en Java, principalement en raison de l’incertitude quant au moment où la collecte des ordures sera effectuée.
Dans les temps modernes, la vitesse d'application ou d'exécution n'est pas aussi importante qu'auparavant. Les calendriers de développement, l'exactitude et la robustesse sont des priorités plus élevées. Une version à grande vitesse d'une application ne sert à rien si elle contient beaucoup de bugs, se bloque beaucoup ou pire, manque une occasion de se rendre sur le marché ou d'être déployée.
Les programmes de développement étant une priorité, de nouveaux langages sont créés pour accélérer le développement. C # est l'un d'entre eux. C # contribue également à l'exactitude et à la robustesse en supprimant les fonctionnalités de C++ qui causent des problèmes courants: les pointeurs, par exemple.
Les différences de vitesse d'exécution d'une application développée en C # et d'une autre développée en C++ sont négligeables sur la plupart des plateformes. Cela est dû au fait que les goulots d'étranglement d'exécution ne dépendent pas de la langue mais dépendent généralement du système d'exploitation ou des E/S. Par exemple, si C++ exécute une fonction en 5 ms mais que C # utilise 2 ms et que l'attente de données prend 2 secondes, le temps passé dans la fonction est insignifiant comparé au temps d'attente de données.
Choisissez le langage le mieux adapté aux développeurs, à la plate-forme et aux projets. Travaillez vers les objectifs de correction, de robustesse et de déploiement. La vitesse d'une application doit être traitée comme un bogue: hiérarchisez-la, comparez-la à d'autres bogues et corrigez-la si nécessaire.
Pourquoi voudriez-vous écrire une petite application qui ne nécessite pas beaucoup d'optimisation en C++, s'il existe une route plus rapide (C #)?
Obtenir une réponse exacte à votre question n'est vraiment possible que si vous effectuez des tests de performances sur des systèmes spécifiques. Cependant, il est toujours intéressant de réfléchir à certaines différences fondamentales entre les langages de programmation tels que C # et C++.
Compilation
L'exécution du code C # nécessite une étape supplémentaire dans laquelle le code est JIT. En ce qui concerne les performances, ce sera en faveur de C++. En outre, le compilateur JIT est uniquement capable d'optimiser le code généré dans l'unité de code qui est traitée par JIT (par exemple, une méthode), tandis qu'un compilateur C++ peut optimiser des appels de méthodes utilisant des techniques plus agressives.
Cependant, le compilateur JIT est capable d'optimiser le code machine généré pour correspondre au matériel sous-jacent, lui permettant de tirer parti des fonctionnalités matérielles supplémentaires, le cas échéant. À ma connaissance, le compilateur .NET JIT ne le fait pas, mais il pourrait éventuellement générer un code différent pour Atom par opposition aux processeurs Pentium.
Accès mémoire
L'architecture mal ordonnée peut dans de nombreux cas créer davantage de modèles d'accès à la mémoire optimaux que le code C++ standard. Si la zone de mémoire utilisée pour la première génération est suffisamment petite, les performances du cache du processeur peuvent augmenter. Si vous créez et détruisez un grand nombre de petits objets, la surcharge liée au maintien du segment de mémoire géré peut être inférieure à celle requise par le moteur d'exécution C++. Encore une fois, cela dépend fortement de l'application. Une étude des performances Python démontre qu'une application Python gérée spécifique est capable de faire évoluer sa capacité bien mieux que la version compilée grâce à des modèles d'accès de mémoire plus optimaux.
La principale préoccupation ne serait pas la vitesse, mais la stabilité entre les versions et les mises à niveau de Windows. Win32 est généralement immunisé contre les versions de Windows, ce qui le rend extrêmement stable.
Lorsque les serveurs sont mis hors service et que les logiciels sont migrés, beaucoup d'inquiétudes autour de .Net sont présentes et une panique généralisée entourant les versions .net, mais une application Win32 construite il y a 10 ans continue de fonctionner comme si de rien n'était.
Ne laissez pas déroutant!
Si une application C # est écrite dans le meilleur des cas et qu'une application C++ est écrite dans le meilleur des cas, le C++ est plus rapide.
Plusieurs raisons expliquent pourquoi C++ est plus rapide que C # de manière inhérente, par exemple, C # utilise une machine virtuelle similaire à la JVM en Java. Fondamentalement, un langage de niveau supérieur a moins de performances (s'il est utilisé dans le meilleur des cas).Si vous êtes un programmeur professionnel expérimenté en C # comme vous êtes un programmeur professionnel expérimenté en C++, le développement d'une application utilisant C # est beaucoup plus simple et rapide que le C++.
Beaucoup d'autres situations entre ces situations sont possibles. Par exemple, vous pouvez écrire une application C # et une application C++ pour que l'application C # s'exécute plus rapidement que C++.
Pour choisir une langue, vous devez noter les circonstances du projet et son sujet. Pour un projet d’entreprise général, vous devez utiliser C #. Pour un projet exigeant des performances élevées, tel qu'un projet de convertisseur vidéo ou de traitement d'image, vous devez choisir C++.
Mettre à jour:
D'ACCORD. Permet de comparer certaines raisons pratiques expliquant pourquoi la vitesse maximale de C++ est supérieure à C #. Considérons une bonne application écrite C # et la même version C++:
- C # utilise un VM en tant que couche intermédiaire pour exécuter l'application. Il a des frais généraux.
- AFAIK CLR n'a pas pu optimiser tous les codes C # de la machine cible. L'application C++ peut être compilée sur la machine cible avec la plupart des optimisations.
- En C #, l'optimisation la plus grande possible pour l'exécution signifie la VM la plus rapide possible. VM a de toute façon des frais généraux.
- C # est un langage de niveau supérieur et génère donc plus de lignes de code de programme pour le processus final. (tenez compte de la différence entre une application Assembly et Ruby, une! la même condition existe entre C++ et un langage de niveau supérieur tel que C #/Java)
Si vous préférez obtenir plus d’informations dans la pratique en tant qu’expert, voir ceci . Il s’agit de Java mais s’applique également à C #.