Comment beaucoup plus rapide est le C++ que le C#?

Ou est-il maintenant dans l'autre sens?

De ce que j'ai entendu qu'il y a certains domaines dans lesquels des C# s'avère être plus rapide que le C++, mais je n'ai jamais eu le courage de le tester par moi-même.

Pensé que l'un de vous pourrait expliquer ces différences dans le détail ou de m'indiquer le bon endroit pour des informations sur cette.

Protégées, afin d'éviter tout plus aléatoire repères d'être publiés. Si vous pensez que vous pouvez faire de votre cas, vous aurez besoin de 10 rep à le faire.
Comment cela est-il pas fermé comme avis/argumentatif de toute façon? Ne suis-je pas encore sur StackOverflow? (Ne suggère pas la fermer, juste curieux. J'aime les questions qui incitent à la opiniâtre arguments)
C'est presque une plaidoirie en question, étant donné que nous vivons dans un âge où IL peut être converti au RPC et optimisé à partir de là: docs.unity3d.com/Manual/IL2CPP.html

InformationsquelleAutor Trap | 2008-09-26

benchmarking c#c++performance

312

Il n'y a pas de stricte raison pour laquelle un code binaire en fonction des langages comme le C# ou Java, qui a une équipe commune d'enquête ne peut pas être aussi rapide que du code C++. Cependant, C++ code utilisé pour être beaucoup plus rapide pour une longue période de temps, et aussi, aujourd'hui encore, dans beaucoup de cas. Ceci est principalement dû à la plus avancée optimisations JIT être compliqué à mettre en œuvre, et la vraiment cool, n'arrivant tout à l'heure.

C++ est plus rapide, dans de nombreux cas. Mais ce n'est qu'une partie de la réponse. Le cas où C++ est en fait plus rapide, sont hautement optimisé programmes, où les programmeurs experts soigneusement optimisé l'enfer hors du code. Ce n'est pas seulement beaucoup de temps (et donc cher), mais aussi souvent conduit à des erreurs dues à la sur-optimisation.

D'autre part, le code dans des langages interprétés devient plus rapide dans les dernières versions du moteur d'exécution (.NET CLR ou de la machine virtuelle Java), sans que vous fassiez quoi que ce soit. Et il y a des tas d'optimisations compilateurs JIT pouvez faire qui sont tout simplement impossible dans les langues avec des pointeurs. En outre, certains prétendent que la collecte des ordures doit généralement être aussi rapide ou plus rapide que le manuel de gestion de la mémoire, et dans de nombreux cas, il est. Vous pouvez généralement mettre en œuvre et de réaliser tout cela en C++ ou en C, mais il va être beaucoup plus compliqué et source d'erreurs.

Comme Donald Knuth a dit, "l'optimisation prématurée est la racine de tout mal". Si vous savez vraiment pour vous assurer que votre demande sera consistent pour la plupart en très critique pour les performances de l'arithmétique, et qu'il sera le goulot d'étranglement, et il va certainement être plus rapide en C++, et vous êtes sûr que C++ n'entre pas en conflit avec d'autres exigences, optez pour C++. Dans les autres cas, se concentrer sur la première mise en œuvre de votre demande correctement dans la langue dans laquelle vous convient le mieux, puis de trouver les goulots d'étranglement des performances si elle est trop lente, et ensuite réfléchir à comment optimiser le code. Dans le pire des cas, vous pourriez avoir besoin de faire appel à du code C par l'intermédiaire d'un étranger interface de la fonction, de sorte que vous aurez toujours la possibilité d'écrire des critiques de pièces dans le langage de plus bas niveau.

Garder à l'esprit qu'il est relativement facile d'optimiser un programme correct, mais beaucoup plus difficile à corriger un programme optimisé.

Donnant les pourcentages réels de vitesse avantages est impossible, il dépend en grande partie de votre code. Dans de nombreux cas, le langage de programmation de la mise en œuvre n'est même pas le goulot d'étranglement. Prendre des repères au http://benchmarksgame.alioth.debian.org/ avec beaucoup de scepticisme, comme ces en grande partie test arithmétique code, ce qui est le plus susceptible de ne pas similaire à votre code.
- <citation>le code dans des langages interprétés devient plus rapide dans les versions ultérieures de l'exécution</citation> Comme le code compilé par une meilleure version du compilateur va également obtenir plus rapidement.
- Notez que, si sb a pour code critique pour les performances de l'arithmétique, il est préférable de code en Fortran, sinon donner des conseils pour le compilateur C++ que les données ne sont pas lissés par d'autres pointeurs.
- En fait il y a au moins une raison: JIT doit être rapide, et ne peut pas se permettre de passer du temps sur les différentes optimisations avancées disponibles pour un compilateur C++.
- Trifunovic (: dépend de votre scénario. Dans les applications serveur, JIT n'a pas vraiment besoin d'être rapide, vous pouvez amortir le coût au fil du temps très bien, et d'effectuer des améliorations progressives sur le code.
- J'aime le C++, mais c'est probablement parce que je programme des jeux où presque tout est incroyablement mathématiques lourds (physique, collison, pondérée filet de déformation des trucs comme ça.)
- "mais aussi souvent conduit à des erreurs dues à la sur-optimisation." [citation désespérément nécessaire]. Je travaille dans un laboratoire national, et nous optimisons l'enfer hors de notre code. Ce n'est pas commun dans le code bogué.
- beaucoup de scepticisme" - non, pas du scepticisme. L'attitude appropriée est la curiosité de voir les points de référence FAQ du jeu "Imparfait Repères".
- "Il est relativement facile d'optimiser un programme correct, mais beaucoup plus difficile à corriger un programme optimisé."
- York: Mais le nouveau JIT peut également exécuter plus anciennes assemblées plus rapide, le nouveau compilateur est inutile sans une nouvelle compilation 😉
- C# est programmé en C++, donc je ne vois pas comment il pourrait éventuellement être plus vite plus vite que le C++. Au mieux, C# ne peut être aussi rapide que du C++. Puis de nouveau, .NET a un tas géré par, géré pool de threads, etc. qui peut rendre votre code plus rapide qu'un programme C++ qui n'ont pas ces gestionnaires - mais ce sont les fonctionnalités de .NET et pas de la programmation C# lanugage lui-même.
- ..pour clarifier: le compilateur C# et le .NET CLR & CLI est programmé en C++.
- Inge: vous ne savez pas vous êtes sur la bonne voie là. Oui, le C# est mis en œuvre dans une autre langue, mais le compilateur JIT est la génération de code machine, il n'est donc pas un langage interprété. Il n'est donc pas limitée par ses C++ mise en œuvre. Je ne suis pas quire sûr de savoir pourquoi vous pensez que l'ajout de certains gestionnaire de quelque chose d'intrinsèquement le rend plus rapide.
- doit être rapide, et ne peut pas se permettre de passer du temps sur les différentes optimisations avancées disponibles pour un compilateur C++". Qui est souvent affirmé, mais je n'ai jamais vu aucune preuve de cela. Pouvez-vous citer quelques exemples concrets de telles optimisations?
- JIT signifie que vous avez un compilateur à l'environnement d'exécution. Il n'y a aucune raison de ne pas recompiler un programme C++ avec un nouveau compilateur.
- Sauf qu'il nécessite un redéploiement? Pour les systèmes serveur, assurez-vous aller de l'avant et de recompiler le logiciel avec les plus modernes, les compilateurs qui ont plus d'optimisations avancées. Mais pour le marché de la consommation, vous ne pouvez généralement pas le faire jusqu'à ce que vous expédier une nouvelle version. Avec .NET un programme compilé il y a 8 ans, peut soudainement devenir plus rapide en raison de l'optimisation en un nouveau .NET Framework.
- Que pensez-vous de la nouvelle C# "roslyn" compilateur? J'ai entendu dire qu'il accélère vraiment le code de manière significative
- Roslyn est un compilateur de C# pour le bytecode. Il y a très peu d'optimisations fait à cette étape, depuis l'optimisation agressive à ce stade pourrait prévenir plus d'optimisations avancées à l'équipe de temps. Cependant, vous êtes probablement parler de RyuJIT, le nouveau compilateur JIT, qui possède plusieurs grandes améliorations de performances.
- en fait, le point principal est que certaines choses ne peuvent être fait de manière efficace en C#, mais peut être fait de manière efficace en C++ par exemple, AMP Peut-être que c'est juste temporaire, mais actuellement c'est comme ça.
- [Donald E. Knuth, 2008-04-25] "X" peuvent produire des milliers de fichiers binaires, adaptés à des configurations des utilisateurs individuels, alors que le "Y", généralement, n'existent que pour quelques versions. Un générique fichier exécutable binaire doit inclure des choses comme inefficace "sync" instructions qui sont totalement inapproprié pour la plupart des installations; ce gaspillage disparaît lorsque le code source est hautement configurable. Cela devrait être une grande victoire pour "X".
- Je dirais que c'est plus que le bytecode vs natif, c'est aussi sur la langue elle-même, si la langue n'est pas assez expressif (et je pense que les deux C# et Java entrent dans cette catégorie) pour exprimer les choses de manière efficace pour le backend, vous allez perdre, peu importe si votre langue maternelle ou bytecode/IL etc, les langues autochtones peut être lent, trop; je crois personnellement que le bytecode obtient plus de mérite qu'il se doit, et pour la plupart, tout devrait être natif natif peut être utilisable aussi; c'est également la question est de savoir jusqu'où vous devez aller, avez-vous vraiment besoin de tout jusqu'à la dernière du cycle? parfois, vous faites, la plupart du temps vous n'avez pas
- Ce n'est pas vrai même lorsque vous avez posté. Ce n'est pas couramment utilisé, mais .NET a bénéficié du soutien de sap pour un moment, et autant que je sache JVM a trop. N'oubliez pas que le C# peut traiter avec une mémoire non managée et des pointeurs très bien - c'est juste un peu plus de travail qu'en C++ (un peu similaire à C, en fait). Si vous voulez le code managé et C++, C++ Managé vous donne les deux en même temps (même si évidemment, la partie native de code n'est pas multi-plateforme). Et .NET, interop extrêmement facile, de sorte que vous pouvez toujours tomber natif C++ si vous en avez besoin. Ou VB6, quelle que soit la flotte votre bateau.
- Je pense que j'ai vu que dans une vieille interview à l'égard des "Indigènes C++" de l'initiative, ne me souviens pas exactement qui ou quand donc, vous avez probablement raison.
- Je ne pense pas que le code généré par un compilateur C++ est nécessairement plus rapide (ou plus lent) que le code généré par un compilateur C#. Je pense que C++ donne beaucoup plus de contrôle sur les caractéristiques et les performances de votre code de C#.
- Quand vous avez mentionné ceci: "Et il y a des tas d'optimisations compilateurs JIT pouvez faire qui sont tout simplement impossible dans les langues avec des pointeurs," avez-vous été référencement aliasing des optimisations?
- "Il n'y a pas de stricte raison pour laquelle un code binaire en fonction des langages comme le C# ou Java, qui a une équipe commune d'enquête ne peut pas être aussi rapide que du code C++." bien Sûr. Pour une chose, les compilateurs JIT avoir plus de temps limité pour compiler le code que AoT les compilateurs. C'est suffisant pour les mettre dans une situation désavantageuse.
- "l'optimisation prématurée est la racine de tous les maux", cette vieille citation ne tient pas en pratique. Vous avez besoin à la conception de la performance de l'aller. Toujours cette croyance que l'équipe sera mieux que les langages compilés statiquement, mais dans la pratique, il semble ne jamais tout à fait arriver, pour des raisons logiques ( abstraction de gestion de la mémoire pour la plupart ). En outre, les avantages supposés d'une équipe commune d'enquête est basée sur le fait qu'il y a un grand nombre de Processeurs pour optimiser, qui dans la pratique n'est certainement pas le cas.
InformationsquelleAutor Martin Probst
183

C# ne peut pas être plus rapide, mais il VOUS fait/ME plus rapide. C'est la mesure la plus importante pour ce que je fais. 🙂
- Haha, il y a une citation de Larry Wall sur le sujet. Il parle à propos de perl, mais il peut être pensé pour toutes les discussions concernant des langues et de la performance: "..plus tôt les langages informatiques, tels que le Fortran et C, ont été conçus pour rendre efficace l'utilisation de coûteux matériel informatique. En revanche, Perl est conçu pour rendre l'utilisation efficace de l'ordinateur coûteux programmeurs"
- 1. "C# est beaucoup plus rapide que le C++" 2. "Il ne peut pas être vrai" 1. "Sûr qu'il peut" 2. "De combien?" 1. "Habituellement de 3 à 4 mois"
- pour le C++, qui dépend vraiment de la bibliothèques de votre aide, C# n'est pas généralement plus rapide, .NET est, quand vous parlez de la productivité
- C'est la même raison pourquoi vous pouvez utiliser Python au lieu de C à écrire un peu de code... mais après la création de certains gros calculs, vous pouvez sentir la différence dans la performance.
InformationsquelleAutor mattlant
78

Il est cinq oranges plus rapide. Ou plutôt: on ne peut pas (correctement) couverture de réponse. C++ est un langage compilé statiquement (mais alors, il y a le profil de l'optimisation orientée, trop), C# exécute aidé par un compilateur JIT. Il y a tellement de différences que des questions comme “comment beaucoup plus rapide” n'ont pas de réponse, pas même en donnant des ordres de grandeur.
- Avez-vous des preuves à l'appui de votre scandaleux cinq oranges demande? Mes expériences de tous les points de 2 oranges au plus, avec un 3 à la mangue amélioration lors modèle de la métaprogrammation.
- Chez la levure, il n'est pas clamming c'est des hors-d'œuvre de grandeur plus rapide.
- De mon expérience, c'est plutôt 5.2 oranges. Mais cela dépend de la fruit-o-meter vous utilisez.
- Mise à jour, StackOverflow lui-même foiré et poignées de commentaires inefficace, donc moins de bananes (300 bananes pire que devrait être le cas): meta.stackexchange.com/questions/254534/...
InformationsquelleAutor Konrad Rudolph
70

Je vais commencer par en désaccord avec une partie de la accepté (et de bien-upvoted), la réponse à cette question en déclarant:

Il y a effectivement beaucoup de raisons pourquoi JITted code fonctionne plus lentement que d'un C++ optimisé (ou une autre langue sans gestion d'exécution)
programme y compris:
- cycles de calcul de passé sur JITting code au moment de l'exécution, par définition, pas disponible pour une utilisation dans l'exécution du programme.
- tout chaud chemins de la Gigue sera en concurrence avec votre code pour l'enseignement et le cache de données dans la CPU. Nous savons que cache domine quand il s'agit de la performance et natif de langages tels que le C++ n'ont pas ce type de conflit, par définition.
- au moment de l'exécution de l'optimiseur de budget-temps est nécessairement beaucoup plus limitée que celle d'un moment de la compilation de l'optimiseur (comme un autre intervenant a souligné
Bas de ligne: en fin de compte, vous sera presque certainement être en mesure de créer une mise en œuvre plus rapide en C++ que vous pourriez en C#.

Maintenant, avec cela dit, comment beaucoup plus rapide n'est pas vraiment quantifiable, comme il y a trop de variables: la tâche, domaine de problème, le matériel, la qualité de mises en œuvre, et de nombreux autres facteurs. Vous devrez exécuter des tests sur votre scénario afin de déterminer la différence de performance, et ensuite décider s'il vaut la peine l'effort supplémentaire et de la complexité.

C'est un très long et complexe sujet, mais je pense qu'il vaut la peine de mentionner, par souci d'exhaustivité que de C#runtime optimizer est excellente, et est capable d'effectuer certaines optimisations dynamiques à l'exécution qui sont tout simplement pas disponibles pour C++ avec le moment de la compilation (statique) de l'optimiseur. Même avec cela, l'avantage est toujours que profondément dans l'application native de la cour, mais la dynamique de l'optimiseur est la raison pour laquelle le "presque certainement" qualificatif donné ci-dessus.

--

En termes de performance relative, j'ai été troublé par les chiffres et les discussions que j'ai vu dans certains autres réponses, j'ai donc pensé carillon et dans le même temps, offrir un peu de soutien pour les déclarations que j'ai faites ci-dessus.

Une énorme partie du problème avec ces critères est que vous ne pouvez pas écrire du code C++ comme si vous avez été écrit en C# et s'attendre à obtenir des résultats représentatifs (par exemple. l'exécution des milliers d'allocations de mémoire en C++ va vous donner de terribles chiffres.)

Au lieu de cela, j'ai écrit un peu plus idiomatique de code C++ et comparé le code C# @Wiory fourni. Les deux principaux changements que j'ai faits pour le code C++ ont été:

1) vector::reserve()

2) aplati le tableau 2d de 1d pour atteindre la meilleure localité de cache (bloc contigu)

C# (.NET 4.6.1)
```
private static void TestArray()
{
    const int rows = 5000;
    const int columns = 9000;
    DateTime t1 = System.DateTime.Now;
    double[][] arr = new double[rows][];
    for (int i = 0; i < rows; i++)
        arr[i] = new double[columns];
    DateTime t2 = System.DateTime.Now;

    Console.WriteLine(t2 - t1);

    t1 = System.DateTime.Now;
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < columns; j++)
            arr[i][j] = i;
    t2 = System.DateTime.Now;

    Console.WriteLine(t2 - t1);
}
```
Moment de l'exécution (Libération): Init: 124ms, Remplissage: 165ms

C++14 (Clang v3.8/C2)
```
#include <iostream>
#include <vector>

auto TestSuite::ColMajorArray()
{
    constexpr size_t ROWS = 5000;
    constexpr size_t COLS = 9000;

    auto initStart = std::chrono::steady_clock::now();

    auto arr = std::vector<double>();
    arr.reserve(ROWS * COLS);

    auto initFinish = std::chrono::steady_clock::now();
    auto initTime = std::chrono::duration_cast<std::chrono::microseconds>(initFinish - initStart);

    auto fillStart = std::chrono::steady_clock::now();

    for(auto i = 0, r = 0; r < ROWS; ++r)
    {
        for (auto c = 0; c < COLS; ++c)
        {
            arr[i++] = static_cast<double>(r * c);
        }
    }

    auto fillFinish = std::chrono::steady_clock::now();
    auto fillTime = std::chrono::duration_cast<std::chrono::milliseconds>(fillFinish - fillStart);

    return std::make_pair(initTime, fillTime);
}
```
Moment de l'exécution (Libération): Init: 398µs (oui, c'est microsecondes), le Remplir: 152ms

Total des temps d'Exécution: C#: 289ms, C++ 152ms (environ 90% plus rapide)

Observations
- Changer le C# de mise en œuvre de la même 1d de la matrice de mise en œuvre
  donné Init: 40ms, Remplissage: 171ms, Total: 211ms (C++ était encore presque
  40% plus rapide).
- Il est beaucoup plus difficile à concevoir et à écrire "rapide" code en C++ que d'écrire une "régulière" code de langue.
- C'est (peut-être) étonnamment facile d'obtenir des performances médiocres en C++, nous avons vu que, avec sans réserve des vecteurs de la performance. Et il y a beaucoup de pièges de ce genre.
- C#'s la performance est plutôt étonnant quand on considère tout ce qui se passe au moment de l'exécution. Et que le rendement est relativement facile à
  d'accès.
- Plus anecdotiques en comparaison des données de la performance de C++ et C#: https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=gpp&lang2=csharpcore
La ligne de fond est que le C++ vous donne beaucoup plus de contrôle sur la performance. Voulez-vous utiliser un pointeur? Une référence? La pile de la mémoire? Tas? Dynamique polymorphisme ou d'éliminer la gestion d'exécution d'une vtable avec polymorphisme statique (à l'aide de modèles/PFI)? En C++, vous avez pour... euh, obtenir faire tous ces choix (et plus) de vous-même, idéalement de manière à ce que votre solution meilleures adresses le problème auquel vous faites face.

Demandez-vous si vous voulez vraiment ou besoin de contrôle, parce que même pour le trivial exemple ci-dessus, vous pouvez voir que, même si il y a une amélioration significative des performances, il nécessite un approfondissement de l'investissement à l'accès.
- downvoted en enfer pour inutile microbenchmark... une application réelle ne sera pas seulement de commencer 10000 fois pour une multiplication de matrice et une application réelle est plusieurs ordres de grandeurs plus énorme.
- merci pour le commentaire. Bien sûr, ce n'est pas un "vrai" programme. Le point de référence a été refactoriser le code C# de référence offerts ailleurs sur cette page, comme la preuve que JITted code est en quelque sorte plus vite que les indigènes--il ne l'est pas, et le point de référence était potentiellement trompeur de nouvelles personnes.
- upvoting pour avoir un véritable indice de référence 😉
- pourquoi avez-vous d'écrire comme ça? Ce sont des gens comme vous qui me fait détester stackoverflow.
- J'ai eu une mauvaise journée 😉 , je suis juste un homme de trop, enlevé mon downvote, mais à mon avis s'applique toujours. Oh s'il vous plaît ne pas détester TELLEMENT juste parce qu'il y a certains "stupide" les gens 🙂 . Ont une belle.
- TOTALEMENT TROMPEUSE DE RÉFÉRENCE. Dans la version C++ vous êtes tout simplement en réservant une partie de la mémoire (et puis en admirant la façon dont cette opération prend quelques microsecondes à exécuter). Dans la version C# vous êtes à la création de 5000 TABLEAUX (l'instanciation d'objets en mémoire). C++ est plus rapide que le C#... mais la différence est nulle part près de 40%... maintenant c'est plus dans la gamme de <10%. Ce que votre exemple illustre que les programmeurs devraient s'en tenir à la langue de leur choix (et à partir de votre profil, il est évident que vous êtes carrière de programmeur C++). En C#, vous pouvez le faire en 2D array int[,]... suite par exemple.
- Donc, j'ai refait exemple en C# sur ma machine pour utiliser double[,] qui est plus proche de ce qui est utilisé dans l'indice de référence. Il n'est pas encore parfait comparaison, car à peu près tout dans le C# est un objet qui est initialisé dans la mémoire (et il est au-dessus de là). Résultats: l'initialisation a pris 3 ms et exécution a eu 95 ms. J'ai donc pu déclarer que le C# est 40% plus RAPIDE que le C++. Ce qui n'est évidemment pas vrai. Peut-être que ma machine est plus rapide que @U007D. Peut-être que j'ai oublier de mettre en mode Release (puis mon code >300ms à exécuter). Conclusion: la vitesse de code compilé est égal. La façon dont vous avez écrit le code est plus grand facteur.
- À partir de ce que je peux dire, le code en C++ exemple est littéralement juste de l'allocation de la mémoire à l'avance. Le BON C# de la mise en œuvre serait tout simplement écrire "Liste<double> arrs = new List<double>(LIGNES*COLONNES)" qui alloue la mémoire nécessaire à l'index à 2 dimensions tableau à 1 dimension format (par exemple, ce que vous avez fait en C++). Il n'y a absolument aucune raison pour allouer un tableau en 2 dimensions et manuellement aplatissez-la quantité massive d'itérations dans votre pré-test est la cause de la merde à la performance. J'imagine que la surcharge serait encore plus en C#, mais pas par une somme considérable.
- Très inneficient c# de mise en œuvre comme d'autres l'ont dit. Aussi, le temps a été mesuré par la soustraction d'objets DateTime qui n'est pas l'utilisation correcte (Pas assez de précision, plus lourds que le Chronomètre). Ce post prouve juste que les gens préfèrent la langue qu'ils ont de l'expérience, par opposition à en ligne des repères.
InformationsquelleAutor U007D
58

Dans mon expérience (et j'ai beaucoup travaillé avec les deux langues), le principal problème avec C# par rapport à C++ est forte consommation de la mémoire, et je n'ai pas trouvé un bon moyen de le contrôler. C'était la consommation de mémoire qui serait éventuellement ralentir .NET logiciel.

Un autre facteur est que le compilateur JIT ne peut pas se permettre trop de temps à faire des optimisations avancées, parce qu'il fonctionne au moment de l'exécution, et l'utilisateur final serait-il un avis si ça prend trop de temps. D'autre part, un compilateur C++ dispose de tous les temps il a besoin pour faire des optimisations au moment de la compilation. Ce facteur est beaucoup moins important que la consommation de mémoire, à mon humble avis.
- Dans un projet au travail que nous avions à la mine de quantités gigantesques de données, y compris la tenue de plusieurs GO en mémoire simultanément et d'effectuer de coûteux calculs sur l'ensemble de l'il -- ce qui exigeait un contrôle précis de toutes les attributions, C++ était à peu près le seul choix. +1 pour le C++. D'autre part, c'était juste un projet, nous avons passé la plupart de notre temps à écrire des systèmes qui interagissent avec la lenteur des simulateurs, et de débogage peut être un cauchemar, donc je souhaite que nous pourrions avoir utilisé un programmeur à temps-optimisation de la langue pour tous ces autres trucs.
- Vous pouvez forcer le tas managé pour disposer des objets. Voir msdn.microsoft.com/en-us/library/... pour plus d'info.
- Je suis bien conscient de la modèle dispose, mais il n'aide pas à la gestion de la mémoire à tous.
- disposer celui-ci garantit que le Rebut méthode a été appelée. L'élimination ne libère pas le garbage collector de la mémoire. La méthode dispose est prévu uniquement pour le nettoyage de ressources non managées comme des descripteurs de fichier et n'a rien à voir avec la gestion de la mémoire.
- le compilateur ne peut pas se permettre trop de temps à faire des optimisations avancées". Pouvez-vous citer quelques optimisations qui ne sont pas fait par des équipes communes d'enquête parce qu'elles prennent trop de temps?
- Mais aussi de la mémoire bon marché ces jours-ci, c'est un gros problème pour ajouter 32GB, ou au lieu de laisser quelqu'un code de quelques mois de plus en c++ (grand projet), comparé à c#.
- Même si l'ajout de RAM est toujours possible (et il n'est pas en imaginer de Microsoft ajouter de la RAM à chaque MS Bureau de l'utilisateur) qui ne permettra pas de résoudre le problème. La mémoire est hiérarchique et d'un programme C# aura beaucoup plus de cache que C++.
- Cela ressemble à Jeter n'ont quelque chose à voir avec la gestion de la mémoire... Quand vous "nettoyer les ressources non managées", la mémoire qui contient ces ressources est libéré, droit?
- Eh bien, oui, mais finalement, ces ressources seront libérées par le finaliseur même si vous oubliez d'appel Dispose. Oublier de déposer immédiatement un fichier ouvert en mode exclusif pourrait être un problème majeur, il peut bloquer l'ouverture d'ailleurs pour un temps déraisonnable. Vous pourriez accidentellement laisser les verrous de fichier tenue. Les fuites sont encore possible avec un garbage collector, si vous avez accidentellement garder des références accessibles inutilement.
- Merci, quelqu'un qui apporte une réponse plutôt que de simplement dire "oh ça dépend... blablabla".
InformationsquelleAutor Nemanja Trifunovic
33

Un scénario particulier où C++ a toujours la haute main (et, pour les années à venir) se produit lorsque polymorphes décisions peuvent être déterminées à l'avance au moment de la compilation.

Généralement, l'encapsulation et différés la prise de décision est une bonne chose, car cela rend le code plus dynamique, plus facile de s'adapter à l'évolution des besoins et plus facile à utiliser comme un cadre. C'est pourquoi la programmation orientée objet en C# est très productive et il peut être généralisée sous le terme de “généralisation”. Malheureusement, ce genre de généralisation vient à un coût au moment de l'exécution.

Généralement, ce coût est non-substantiel, mais il y a des applications où la surcharge de méthode virtuelle des appels et de la création d'un objet peut faire une différence (surtout depuis que les méthodes virtuelles d'empêcher d'autres optimisations telles que l'appel de la méthode inline). C'est là que le C++ a un énorme avantage, car vous pouvez utiliser des modèles pour atteindre à une sorte de généralisation qui a pas impact sur runtime mais il n'est pas forcément moins polymorphes que la programmation orientée objet. En fait, tous les mécanismes qui constituent la programmation orientée objet peut être modélisé à l'aide seulement du modèle de techniques et de compilation de résolution.

Dans de tels cas (et, certes, ils sont souvent restreintes à des problèmes spéciaux domaines), C++ gagne contre C# et comparables langues.
- En fait, de machines virtuelles Java (et probablement .NET) font de grands efforts pour éviter la distribution dynamique. En gros, si il y a un moyen d'éviter de polymorphims, vous pouvez être sûr de votre VM va le faire.
- Je suis conscient de la VMs' capacités. Cependant, cela va beaucoup plus loin. Le point est que modèle C++ codes ne utiliser la “dynamique” d'expédition, ou plutôt, quelque chose d'analogue.
- +1 j'ai toujours du mal à expliquer cela à mes C# collègues qui connaissent peu de C++ de manière à leur permettre d'apprécier l'importance. Vous nous avez expliqué ça plutôt bien.
- Mais lorsque le peignage code à partir de plusieurs propriétaires, je crois qu'il est encore vrai que le modèle d'instanciations sont très difficiles à partager entre le module de limites. Je parle de partage de code commun comme List<T> ou vector<T> à travers de nombreux modules dans une même application. Donc, pour composable systèmes (nombre de modules, de nombreux propriétaires) temps d'exécution comme le CLR commencer à faire leurs frais fixes par la réduction de la dérouillée de la cache du PROCESSEUR avec plusieurs copies du même modèle instanciations. Je pense que dans le temps les performances de C++ plomb diminuera jusqu'à ce qu'niche bibliothèques et de type C les bibliothèques restent.
- vous faites votre mise sans de calcul de haute performance des applications. Envisager des prévisions météorologiques, de la bioinformatique et des simulations numériques. Les résultats de C++ dans ces zones, pas réduire, parce qu'aucun autre code peut atteindre des performances comparables au même niveau élevé d'abstraction.
- C# est natif de la compilation du code de la durée d'exécution du code généré qui est un plus de solution générale à ce problème. Par exemple, les expressions régulières sont compilées en code machine en C# alors que C++ recours à un interprète. Vous ne pouvez pas utiliser des modèles pour le faire en C++ si l'expression régulière est uniquement disponible au moment de l'exécution. Ainsi, dans le cas général, le C# est un ordre de grandeur plus rapide que le C++ dans le cadre de la métaprogrammation.
- Utiliser un meilleur moteur d'expressions régulières en C++ alors (il y a peut-être pas un; mais ce n'est pas une restriction fondamentale – mais en réalité, il y a est ces moteurs, par exemple Boost.Xpressive). Votre deuxième déclaration est risible.
- Vous pouvez utiliser une bibliothèque comme LLVM pour générer dynamiquement du code natif en C++ si vous le souhaitez. Il n'y a pas de restriction de langue contre elle. Ce serait une mise en œuvre juridique de std::regex.
- D'ailleurs, pour éviter tout malentendu, je concède que le C# métaprogrammation est plus puissant parce que vous pouvez l'utiliser lors de l'exécution. Je suis prise d'un problème avec vos “ordres de grandeur plus rapide” réclamation qui est plat mal.
- Oui, bien sûr. Vous pouvez résoudre tout problème rapidement dans n'importe quelle langue, par la génération de la coutume du code machine.
- la prise d'un problème avec vos “ordres de grandeur plus rapide” réclamation qui est plat mal". Gros comment pensez-vous la différence de performances entre un interprète et le code généré par un compilateur optimisant l'est? J'ai vu Mathematica exécuter de 100 000 x plus lent que le C...
- Les pommes et les oranges. Votre demande a été “C# est un ordre de grandeur plus rapide que le C++ dans le cadre de la métaprogrammation”, pas “à l'aide de code précompilé est un ordre de grandeur plus rapide que le code interprété”. Pendant que nous y sommes, votre demande d'exécution de la génération de code est “plus général” que le moment de la compilation génération de code est également manifestement mal – ils tous les deux ont des forces et des faiblesses. Au moment de la compilation génération de code utilise le type de système pour fournir le type statique de la sécurité d'exécution de génération de code ne peut pas le faire (peut fournir une forte sécurité de type, mais pas statique type de sécurité).
- prétendre que l'exécution de la génération de code est “plus général” que le moment de la compilation génération de code est également manifestement mal". Au moment de l'exécution codegen peut gérer à la fois statiquement et dynamiquement les programmes disponibles alors que la compilation ne peut gérer de manière statique de programmes disponibles. "runtime de génération de code ne peut pas le faire". MetaOCaml est un contre-exemple.
- C'est bien joli tout cela, mais complètement académique. Ni C++ et C# peuvent le faire. Toute cette discussion est sur C# et C++.
- Pourriez-vous commenter la 13x différence de performances, j'ai décrit ici: stackoverflow.com/questions/19798653/c-vs-net-regex-performance
- en fait C# ne comprennent des moyens pour inline vos fonctions à l'aide du Système.Moment de l'exécution.CompilerServices; ... [Attribut Methodimpl(MethodImplOptions.AggressiveInlining)] void MyMethod(...)
- Personne ne conteste que les, mais je ne sais pas un seul de la mise en œuvre de l' .net qui pourrait l'utiliser pour inline, disons, les appels à un IComparer l'intérieur de la boucle d'un algorithme de tri. C++ peut le faire.
- vous le placez au-dessus de la fonction de votre appel, vous pouvez le faire plusieurs fois, donc, une fonction peut utiliser une sous-fonction, et la subfuction sera placé à l'intérieur de votre fonction main (lors de la compilation) (ea pas de sauts ou des appels); mais vous m vol besoin d'écrire vos propres mécanismes de tri (et peut-être même paralize eux)
- Cela ne fonctionnera pas si l'algorithme de tri est générique et peut être appelé avec des IComparer types. C'est tout le problème ici, et qui est résolu par le C++’ au moment de la compilation des génériques (= modèles).
- pas exactement sûr de ce que vous avez à l'esprit ici, peut-être mettre vos données dans une struct, et vos fonctions à l'intérieur d'une classe de sorte que vous pourriez faire sans objet-fonctions. (mais peut-être que j'ai besoin de voir le problème que vous avez) des structures des tableaux listes des tables de hachage et des objets de classes sont tous de conception et de performance liées choises, mais pas toujours bien choisies.
- Je pense que vous êtes absent le point de l'ensemble de cette réponse. Bien sûr, vous pouvez contourner ce problème en briser l'encapsulation et de descendre plus bas niveau des structures — vous pouvez écrire assemblée (la plupart) n'importe quelle langue. La chose qui fait de C++ (presque) unique, et particulièrement bien adapté pour la haute performance de la programmation, c'est que vous pouvez construire de haut niveau abstractions qui viennent à aucun runtime coût. Si vous n'avez pas besoin d'écrire d'assemblage comme le code en C++ pour obtenir des performances haut de gamme: un bien écrit sort(arr, generic_comparer) sera aussi efficace qu'un écrit à la main boucle en C++. Il ne sera jamais en C#.
- Oui, C++ pouvez le faire, et c'est une bonne chose. Mais ne pense pas que .NET (ou de la JVM) ne peut pas - pour autant que je sais, maintenant, vous avez raison que le support n'est pas là. Mais dans les deux cas, vous avez déjà le compilateur JIT se déplacer virtuel appels de méthode si vous la plupart du temps appel à la même méthode. L'expansion de ce pour permettre à inline la méthode virtuelle corps est évidemment possible - bien que je ne serais pas surpris, car il n'est pas important pour la plupart des projets, et la solution est très simple. Au lieu de cela, nous pouvons nous attendre à la hausse du niveau des abstractions pour obtenir de meilleurs - par exemple, plus intelligente délégués anonymes.
- Non, il n'est vraiment pas possible. Ce que le C++ peut faire et d'autres langues peuvent pas, c'est que même si l'extérieur de la fonction n'est pas inline, la fonction interne de la volonté. Par exemple, imaginer un Sort méthode qui accepte un comparator argument. En C++, ce comparator peut être incorporé même lorsque Sort ne sera pas. Dans les langues que vous avez énumérés, c'est fondamentalement pas possible, et ce est la conception de restriction, pas une technique qui pourrait disparaître dans l'avenir.
- Vous sous-estimer le fait que l'exécution est gratuit pour optimiser ce qu'il veut tant que le programme en cours d'exécution ne vois pas la différence (sur un seul thread). Il est parfaitement valide l'optimisation de l'inclure à l'intérieur de la fonction, mais il devrait certainement être beaucoup plus intelligents JIT que .NET a droite maintenant. Qu'il allait se passer au moment de l'exécution, oui, mais .NET a suffisamment de métadonnées pour la rendre possible. Et en raison de l'exécution fonctionnalités de compilateur, il est en fait assez facile pour moi d'ajouter ceci au moment de l'exécution, sans compter sur le compilateur JIT - IL est beaucoup plus facile à manipuler que les x86 assemblée.
- Vous confondez ce qui est légal de ce qui est techniquement possible. C++ ne peut le faire que parce qu'il génère un autre à l'extérieur de la fonction pour chaque type de modèle (pour plus de détails, voir stackoverflow.com/a/13722515/1968): la fonction elle-même est marqué avec un (statique) de type. Dans .NET, de l'extérieur de la fonction n'est pas balisé avec des types distincts, ni statique, ni dynamique. Pour générer de séparer le code en fonction de divers paramètres, l'optimiseur de aurait à résoudre un problème qui est, autant que je sache, insolubles.
- Et, juste pour clarifier: est avec cela que je ne veux pas dire que c'est absolument impossible d'effectuer cette optimisation (c'est évidemment idiot), c'est juste que c'est impossible de le faire dans un délai raisonnable (= constante de temps de la complexité en ce qui concerne l'expression de la complexité) — qui est ce qui compte au moment d'évaluer si une optimisation peut être effectuée au moment de l'exécution.
- Oh, mais il n'a pas à être de la même méthode. C'est déjà le cas maintenant, en fait, par exemple avec .NET génériques. Et puisque vous avez délégué de l'identité, il est possible de faire ce aussi efficace que les modèles. N'oubliez pas que le compilateur JIT traite avec de l'IL, qui est d'un très haut niveau de "l'assemblage" de la langue, il a des tonnes d'informations. Ne vous méprenez pas - il est certainement beaucoup plus facile de problème avec C++de modèles, et comme je l'ai dit, je ne m'attends pas à une telle optimisation jamais être mis en œuvre pour .NET, car il y a beaucoup plus de choses utiles qu'ils peuvent mettre en œuvre à la place.
- Toutes mes excuses, obtenu déroutés par mon propre exemple, où Sort était une non-méthode générique dans mon esprit. Vous avez raison, il a correctement un type distinct dans .NET si c'est un générique (pas sûr de Java, qui n'a pas réifiée génériques après tout ... mais peut-être le moteur d'exécution assure le suivi de ces données, de toute façon). Oui, vous avez raison.
- Ouais, en Java, les génériques sont un peu plus de sucre syntaxique. Dans .NET, ils sont à l'exécution, fait ainsi - même si j'ai certainement voulu pour les modèles C++ en C# à la fois 🙂 Mais je pense qu'il y a quelques exemples sur la JVM/JRE où un plus puissant système de cotation est utilisée pour pratiquement faire tout le code dans les données, tout à fait semblable à LISP peut-être Clojure? Dans ce cas, tous les indirection peut être retiré à tout moment lors de l'exécution, ce qui devrait permettre à ces inline fonctionne parfaitement, à long avant de vous soucier des complications comme des données locales machines à sous.
InformationsquelleAutor Konrad Rudolph
19

C++ (ou C pour que ce soit), vous donne un contrôle précis sur vos structures de données. Si vous voulez bits-twiddle vous avez la possibilité de. Grand géré Java ou .NET applications (OWB, Visual Studio; 2005) qui utilisent les structures de données internes de l'Java/.NET bibliothèques de porter les bagages avec eux. J'ai vu OWB concepteur de sessions à l'aide de plus de 400 MO de RAM et d'OFFRES pour cube ou ETL conception d'entrer dans le 100 de MO ainsi.

Sur une base prévisible de la charge de travail (comme la plupart des benchmarks que répéter le processus plusieurs fois) une équipe commune d'enquête peut vous obtenir le code est optimisé assez bien qu'il n'y a pas de différence pratique.

De l'OMI sur les grandes applications de la différence n'est pas tellement le JIT que les structures de données que le code lui-même est à l'aide. Lorsqu'une demande est de la mémoire-lourds, vous obtiendrez moins efficace de l'utilisation du cache. Le Cache sur les Processeurs modernes sont assez chers. Où C ou C++ vraiment gagner est là que vous pouvez optimiser votre utilisation de structures de données de jouer gentiment avec le cache du PROCESSEUR.

InformationsquelleAutor ConcernedOfTunbridgeWells
18

Pour les graphiques de la norme C# de la classe Graphics est beaucoup plus lent que GDI accessible via C/C++.
Je sais que cela n'a rien à voir avec la langue en soi, plus de au total .NET plate-forme, mais la carte Graphique est ce qui est offert pour le développeur comme un RIB de remplacement, et sa performance est si mauvais que je n'aurais même pas oser faire des graphiques avec elle.

Nous avons un simple test permet de voir à quelle vitesse une bibliothèque graphique est, et c'est tout simplement le dessin lignes au hasard dans une fenêtre. C++/GDI est encore accrocheur avec 10000 lignes, tandis que le C#/Graphique a de la difficulté à faire 1000 en temps réel.
- J'ai été intrigué par votre réponse. Avez-vous testé le même test avec le code unsafe et lockbits, et le dessin des lignes au hasard vous-même? Maintenant, que serait une chose intéressante à regarder.
- nan je n'ai pas. juste en utilisant le GDI et .NET.Graphiques dans le plus simple des manières. qu'entendez-vous par "dessin au hasard des lignes de vous-même"?
- Alors vous devriez peut-être envisager de tester pour avoir une vue plus réaliste de la métrique pour à quelle vitesse C# peut être. Voici un bel aperçu de la technique: bobpowell.net/lockingbits.htm
- Ce n'est pas ce que nous voulons faire, en mettant séparer les pixels dans un tampon de trame de nous-mêmes. Si vous avez à tout mettre en œuvre vous-même ce qui est le point d'avoir une API/Plate-forme à coder? Pour moi c'est un non-argument. Nous n'avons jamais nécessaire de mettre pixels dans un framebuffer dans l'interface graphique pour tracer des lignes, et nous n'envisageons pas de le faire dans .NET ni. De mon point de vue, on a utilisé un réaliste métrique, et .NET s'est avéré être lent.
- Il est réaliste étant donné que parfois, vous avez besoin pour accélérer votre charte graphique et vous pouvez le faire tout en travaillant au sein de la C#. Je pense que c'est intéressant que vous avez testé cette sorte qu'il aurait été plus intéressant de voir si le C# lockbits méthode est plus rapide que sa C++ homologues.
- Juste point de. WPF est très lent.
- En désaccord, j'ai écrit un camere du filtre ne blob détection dans les 20ms
- Eh bien, j'ai juste une légère idée de ce blob de détection est, mais tout simplement d'énoncer un timing n'a plutôt rien prouver du tout. Avez-vous écrit en C++? En JavaScript? Et par rapport à celui en C#? Et à côté de ça, je ne pense pas que blob de la détection à l'aide de nombreuses primitives graphiques. Corrigez-moi si mauvais, mais je suppose que c'est à des algorithmes statistiques de l'exécution d'opérations sur les pixels.
- Um? WPF ne pas utiliser l'interface graphique, ou le C# de la classe Graphics. Et très lente par rapport à quoi? Sur quel type de matériel? Et comment mesurez-vous le "lent"? Et comment est-ce que C# WPF comparer à C++ WPF? Je suis d'accord que, par exemple, MFC C++ est beaucoup plus rapide que Winforms dans le .NET, mais WPF n'est pas vraiment comparable. Je peux facilement avoir des dizaines de milliers de contrôles WPF sans virtualisation, et de toujours être accrocheur - ni les parents MFC ni Winforms vient n'importe où près.
InformationsquelleAutor QBziZ
13

De la collecte des déchets est la raison principale de Java# NE peut pas être utilisé pour les systèmes en temps réel.
1. Quand le GC se produire?
2. Combien de temps ça va prendre?
C'est non-déterministe.
- Je ne suis pas un grand Java ventilateur, mais il n'y a rien qui dit que Java ne pouvez pas utiliser un temps réel amical GC.
- Il y a beaucoup de temps réel GC implémentations si vous vous souciez de regarder. (GC est un domaine qui est débordant avec des articles de recherche)
- FWIW, Richard Jones, vient de publier une version mise à jour de sa collecte des ordures livre qui traite, entre autres choses, de l'état-of-the-art en temps réel GC dessins.
- Juste parler comme "il y a un RTGC" ne pas répondre à la question sur le déterminisme. Je crois que beaucoup de gens sont encore dans le doute sur ce en raison du manque de réelle explication claire.
- C'est un non-sens argument, Windows (et Linux) ne sont pas en Temps Réel de Systèmes d'exploitation. Votre code C++ peuvent être échangés pour un nombre de 18 ms emplacement à tout moment aussi.
- Vrai, mais vous pouvez toujours écrire un boot-loader dans l'assemblée, une cravate dans un noyau de bootstrap pour votre application et l'exécution de votre C++ applications directement sur le matériel (en RT btw). Vous ne pouvez pas le faire en C# et tous les efforts que j'ai vu seulement imiter pré-assembly compilé en C# et de l'utilisation d'une tonne de code C, qui en font sans le moindre point d'utiliser le C#. La lecture de tous c'est marrant, parce que le C# est vraiment inutile sans la .NET framework.
- en temps réel des ordinateurs sont un oxymore
- Haha, non. Je ne dis pas que C# serait mon premier choix pour un système embarqué avec 32 ko de mémoire, mais c'est seulement parce qu'il y a peu de point dans l'optimisation de toute la partie de C# ou .NET pour ce genre d'environnement. Mais si vous avez au moins une demi-meg de mémoire, vous êtes bon pour aller. Et j'ai écrit un OS en C# à l'avant, et je peux vous dire que c'est génial. Sans la .NET framework, bien sûr. C'est drôle comment vous dire que C# ne peut "imiter" pré-compilés de l'assemblée, alors qu'en C++, vous obtenez ce mode natif... avec de l'assemblée. Ainsi, vous pouvez vous écrire un OS en C++ ou pas? 🙂
InformationsquelleAutor
11

Nous avons eu à déterminer si C# est comparable à C++ dans la performance et j'ai écrit quelques programmes de test pour que (à l'aide de Visual Studio 2005 pour les deux langues). Il s'est avéré que sans la collecte des ordures et de ne tenir compte que de la langue (pas de cadre) C# a pratiquement les mêmes performances que le C++. L'allocation de mémoire est plus rapide en C# qu'en C++ et C# dispose d'un léger avantage dans le déterminisme lorsque des données sont les tailles accrue au delà de la ligne de cache limites. Cependant, tout cela avait fini par être payé et il y a un énorme coût sous la forme de non-déterministe de la performance des hits pour C# grâce à la collecte des déchets.
- En C++, vous avez la possibilité d'utiliser différentes méthodes d'allocation de quotas, donc, en fonction de la façon dont la mémoire a été allouée (AOT?) en C#, il pourrait être fait de la même façon (mais beaucoup plus rapide) en C++.
- a un intéressant bord dans l'allocation de tas, parce qu'il n'a qu'à déplacer un pointeur d'allouer un nouvel objet. C'est uniquement réalisable en raison du compactage garbage collector. Bien sûr, vous pouvez faire la même chose en C++, mais le C++ ne fait pas ça. C'est drôle la façon dont vous utilisez le même argument pour dire "C# pourrait, mais ne l'a pas, donc c'est du caca" et "C++ n'est pas le cas, mais il pourrait, donc, c'est génial" 🙂
InformationsquelleAutor ILoveFortran
9

Comme d'habitude, il dépend de l'application. Il y a des cas où C# est probablement très lent, et d'autres cas où C++ est de 5 ou 10 fois plus rapide, en particulier dans les cas où les opérations peuvent être facilement SIMD avais.
- Dans le meilleur des cas pour les machines virtuelles seront au moment de l'exécution de la compilation du code généré (par exemple, correspondent à une expression régulière lire dans au moment de l'exécution) parce que compilés statiquement à la vanille programmes C++ ne pouvez utiliser de l'interprétation parce qu'ils n'ont pas un compilateur JIT construit en.
- Note de l'avenir: .NET n'a pas le support pour SIMD et amis depuis 2014, si elle n'est pas largement utilisé.
InformationsquelleAutor Dark Shikari
9

Je sais que ce n'est pas ce que vous demandez, mais C# est souvent plus rapide de écrire que C++, qui est un gros bonus dans un cadre commercial.
- Je dirais que c'est plus rapide la plupart du temps 🙂
InformationsquelleAutor Kramii
7

C/C++ peut réaliser infiniment mieux dans les programmes où il y a soit des tableaux grand ou lourd boucle/itération sur des tableaux (de toute taille). C'est la raison pour que les graphiques sont généralement beaucoup plus rapide en C/C++, en raison de lourdes opérations de matrice sous-tendent presque toutes les opérations graphiques. .NET est notoirement lent dans la gamme des opérations d'indexation en raison de tous les contrôles de sécurité, et cela est particulièrement vrai pour les matrices multi-dimensionnelles (et, oui, de forme rectangulaire, C# les tableaux sont encore plus lente que irréguliers C# tableaux).

Les bonus de C/C++ sont les plus prononcés, si vous vous en tenez directement avec les pointeurs et éviter de Boost, std::vector haut niveau et d'autres récipients, ainsi que les inline chaque petite fonction possible. L'utilisation de la vieille école des tableaux chaque fois que possible. Oui, vous aurez besoin de plus de lignes de code pour faire la même chose que vous avez fait en Java ou en C# comme vous d'éviter de haut niveau des conteneurs. Si vous avez besoin d'dynamiquement un tableau de taille, vous aurez juste besoin de se rappeler de la paire de votre new T[] avec un correspondant delete[] instruction (ou utiliser std::unique_ptr)—le prix de la vitesse supplémentaire est que vous devez vous code avec plus de soin. Mais, en échange, vous arrivez à vous débarrasser de la charge de la gestion de la mémoire /garbage collector, qui peut facilement être de 20% ou plus de la durée d'exécution de fortement orienté objet en Java et en .NET, ainsi que ceux massive de la mémoire gérée par le tableau d'indexation des coûts. C++ applications peuvent également bénéficier de quelques chouettes commutateurs de compilateur, dans certains cas spécifiques.

Je suis un expert programmeur en C, C++, Java et C#. J'ai récemment eu l'occasion rare de mettre en œuvre exactement la même algorithmique du programme dans le dernier 3 langues. Le programme a beaucoup de maths et un tableau multi-dimensionnel des opérations. J'ai fortement optimisé ce dans les 3 langues. Les résultats sont typiques de ce que j'ai l'habitude de voir au moins des comparaisons rigoureuses: Java était d'environ 1,3 x plus rapide que le C# (la plupart des machines virtuelles sont plus optimisé que le CLR), et le C++ pointeur brut version est venu dans environ 2,1 x plus rapide que le C#. Notez que le programme C# uniquement utilisé coffre-fort à code—il est de mon avis que vous pourriez aussi bien le code en C++ avant d'utiliser le unsafe mot-clé.

De peur qu'on pense que j'ai quelque chose contre C#, je termine en disant que C# est probablement mon préféré de la langue. C'est le plus logique, intuitive et rapide développement de la langue que j'ai rencontré jusqu'à présent. Je fais tout mon prototypage en C#. Le langage C# a beaucoup de petits, subtil avantages par rapport à Java (oui, je sais que Microsoft a eu la chance de résoudre un bon nombre de Java lacunes en entrant dans le jeu fin et sans doute la copie de Java). Toast à la Java Calendar classe de n'importe qui? Si Microsoft jamais passe réel effort pour optimiser le CLR et le .NET Gigue, C# pourrait sérieusement prendre le dessus. Je suis honnêtement surpris qu'ils n'ont pas déjà fait, ils n'ont donc beaucoup de choses dans le langage C#, pourquoi ne pas poursuivre avec l'percutant les optimisations du compilateur? Peut-être que si nous avons tous beg.
- ", vous aurez juste besoin de se rappeler de la paire de votre new T[] avec un correspondant delete[]" – Non, vous ne le font pas. Il y a std::unique_ptr le faire pour vous.
- Bon point; mise à jour de répondre en conséquence.
- considère que vous avez écrit quelque chose dans les graphiques pourquoi écrire coffre-fort à code en c#, avez-vous envisagé d'utiliser le code unsafe et de comparer à nouveau ?.
InformationsquelleAutor Special Sauce
7

> à Partir de ce que j'ai entendu ...

Votre difficulté semble être de décider si ce que vous avez entendu n'est crédible, et que la difficulté va juste être répétée lorsque vous essayez d'évaluer les réponses sur ce site.

Comment allez-vous décider si les choses que disent les gens ici sont plus ou moins crédible que ce que vous avez entendu à l'origine?

Un autre moyen serait de demander preuve.

Lorsque quelqu'un prétend que "il y a certains domaines dans lesquels des C# s'avère être plus rapide que le C++" leur demander pourquoi ils disent que, demandez-leur de vous montrer mesures, demandez-leur de vous montrer des programmes. Parfois, ils n'ont tout simplement fait une erreur. Parfois, vous verrez qu'ils sont tout simplement exprimer une opinion plutôt que de partager quelque chose qu'ils peuvent montrer pour être vrai.

Souvent de l'information et de l'opinion sera mélangé jusqu'à ce qu'on dit, et vous aurez à les essayer et de trier ce qui est qui. Par exemple, les réponses dans ce forum:
- "Prendre les repères au http://shootout.alioth.debian.org/
  avec beaucoup de scepticisme, comme l'
  ces largement test arithmétique code,
  qui est le plus susceptible de ne pas similaire à
  votre code à tout."
  
  Demandez-vous si vous avez vraiment
  comprendre ce "ces en grande partie test
  l'arithmétique code" moyens, et puis
  demandez-vous si l'auteur a
  effectivement montré que sa demande est
  vrai.
- "C'est plutôt inutile de test, car cela dépend vraiment de la façon dont bien
  les différents programmes ont été
  optimisé; j'ai réussi à accélérer
  certains d'entre eux par 4 à 6 fois ou plus,
  rendre clair que la comparaison
  entre unoptimized programmes
  plutôt ridicule."
  
  Demandez-vous si l'auteur a
  en fait de vous montrer qu'il a réussi
  pour "accélérer certains d'entre eux par 4-6
  fois ou plus" - c'est une simple demande de faire!
- Je ne pouvais pas d'accord avec vous et c'est la raison pour laquelle j'ai demandé à ce forum... Après tout, les réponses doivent être quelque part, n'est-ce pas? 🙂
- Oui. La réponse est "Ça dépend"..
InformationsquelleAutor
6

.NET les langues peuvent être aussi rapide que du code C++, ou encore plus rapide, mais le code C++ ont une plus constant débit que l' .NET a la pause de GC, même si c'est très habile de ses pauses.

Donc si vous avez un peu de code qui a constamment courir vite sans aucune pause .NET va introduire une latence à un certain point, même si vous êtes très prudent avec le runtime GC.
- -1: C'est en fait un mythe. Tout d'abord, la latence de la idiomatiques C++ est en fait terrible et souvent bien pire que .NET parce que RAII provoque des avalanches de destructeurs quand les grandes structures de données compris hors de portée alors que moderne, les tables sont graduels et .NET est voire concurrentes. Deuxièmement, vous pouvez effectivement supprimer complètement GC pause sur .NET en n'affectant pas.
- Si vous faites cela, vous aurez à renoncer à l'aide de la BCL en tant que la plupart des méthodes de créer des objets transitoires.
- C'est tout à fait vrai, il n'était pas jusqu'à ce que .net 4 que le GC a été faite incrémentielle. Nous avons une large application en C# qui fait une pause de quelques secondes à la fois pour le GC. Pour les performances des applications critiques c'est un tueur.
- Il ya une raison pourquoi les programmes qui tendent à pousser le matériel ont tendance à utiliser C++. Vous avez plus fine à l'écoute de contrôle lorsque vous en avez besoin. La Performance est seule touche lorsque vous êtes en poussant le système, sinon utiliser C# ou Java, pour gagner du temps.
- En termes de C# game dev: Vous pouvez correctement le code d'un jeu à ne jamais utiliser la table jusqu'à ce qu'un niveau de transition. Tous les calculs sont effectués via les structures, ce qui signifie que vous n'aurez pas besoin d'initialisation des objets ou lancer une charge continue sur la GC. En fait, le plus grand d'optimisation que vous pouvez faire pour C# game dev est d'essayer de ne pas utiliser le GC à tous. C# vous permet également de forcer GC à tout moment, ce qui peut être fait au niveau des transitions. Fondamentalement, la GC est seulement un problème si vous lui permettez d'être.
- si vous ne pouvez pas gérer le comportement de cache, vous ne pouvez pas battre optimisé le code c++. Un cache L1 de la mémoire principale pourrait ralentir votre opération 100 fois.
- Il suffit de déplacer votre destructeurs pour un sujet séparé. Allés sont les temps de latence.
- Vrai, mais vous pouvez gérer le cache de comportement dans toutes ces langues, bien sûr.
- Vous êtes Greenspunning un GC.
- Pas du tout. Un garbage collector qui identifie la partie de la mémoire est sûr de récupérer et ensuite réclame qu'elle soit dans le même fil que le reste du programme ou dans un autre thread. Je me déplace le nettoyage de code à partir d'un thread à l'autre. Je continue à gérer le nettoyage et de ne pas compter sur la magie de traiter avec elle.
- Donc, vous dites que vous n'êtes pas Greenspunning un GC parce que vous n'êtes pas à l'aide de "magie"?
- Tout bon GC traversée de la mémoire allouée à comprendre les bits ne sont plus accessibles et ensuite récupérer ces bits. Ce n'est pas ce qu'il se passe si vous vous déplacez sur la destruction des objets à un thread différent; vous êtes manuellement déclarant que ces bits sont sûrs de récupérer avec tous les avantages et les problèmes que vous avez en général, et aucun (comme dans pas un seul) des avantages d'un GC. Une plaine GC est mettre en place des latences à semi-aléatoire des endroits dans votre programme; généralement bien pire que RAII volonté et beaucoup moins prévisible.
- bon GC traversée de la mémoire allouée à comprendre les bits ne sont plus accessibles et ensuite récupérer les bits". Comptage de référence est de toute évidence un contre-exemple. "Une plaine GC introduire des latences à semi-aléatoire des endroits dans votre programme; généralement bien pire que RAII". Je ne l'ai jamais vu des latences diminuer lorsque RAII est remplacé par un GC donc je serais ravi de voir que l'hypothèse testée correctement.
- Comptage de référence est exactement ce que j'ai décrit ou c'est potentiellement cassé. J'ai jamais eu d'importants retards causés par la destruction des objets à l'aide de RAII; si vous voyez une diminution des latences avec un GC, je ne peux qu'imaginer l'un des scénarios suivants: (1) vous êtes quelque chose de mal (c'est à dire l'allocation de 1 objet de 1000 fois, plutôt que de 1000 objets à un moment), (2) le GC n'est pas de faire ce qu'elle vous indique qu'elle est en train de faire (pas de nettoyage tout en haut) ou (3) il se déplace à la destruction d'un thread séparé. J'ai vu GCs déplacer à la destruction d'un des nouveaux threads avant.
- le comptage est exactement ce que j'ai décrit ou c'est potentiellement cassé". Désolé mais ce n'est tout simplement pas comment RC fonctionne. Je vous conseille de lire gchandbook.org
- peut seulement imaginer l'un des scénarios suivants". Lorsque les collections de collections tombent hors de portée de la mère destructeurs de manière récursive appeler l'enfant destructeurs jusqu'à ce que l'ensemble de la DAG a été détruite. C'est arbitrairement une longue pause. Différentiels GCs ne pas le faire.
InformationsquelleAutor Florian Doyon
5

Pour "embarassingly parallèles" problèmes lors de l'utilisation de Intel TBB et OpenMP sur le C++, j'ai observé un peu près 10x augmentation des performances similaires (pures mathématiques), des problèmes de fait avec C# et TPL. SIMD est un domaine où le C# ne peut pas rivaliser, mais j'ai aussi eu l'impression que TPL a une importante surcharge.

Cela dit, je ne l'utilise C++ pour la performance de tâches critiques où je sais que je vais être en mesure de multithread et d'obtenir des résultats rapidement. Pour tout le reste, C# (et, occasionnellement, F#) est tout simplement parfait.

InformationsquelleAutor Dmitri Nesteruk
5

C'est extrêmement vague question sans réelle réponse définitive.

Par exemple; je préfère jouer en 3D-jeux qui sont créés en C++ qu'en C#, parce que la performance est certainement beaucoup mieux. (Et je sais de XNA, etc., mais il s'agit pas de façon à proximité de la chose réelle).

D'autre part, comme mentionné précédemment, vous devez développer dans un langage qui permet de faire ce que vous voulez rapidement, et ensuite, si nécessaire optimiser.
- Pourriez-vous citer quelques exemples? Jeux écrite en C# qu'est-ce que vous avez trouvé lent
- Même les applications d'exemple fourni avec l'installation senti lent.
- Le garbage collector est une énorme responsabilité dans la fabrication de jeux avec C#, comme il peut, un coup de pied à tout moment, provoquant de grandes pauses. Explicite de gestion de la mémoire finit par être plus facile pour le développement d'un jeu.
- La plupart des jeux modernes sont GPU limited. Pour ces jeux, il n'a pas d'importance si la logique (exécuté sur le PROCESSEUR) est de 10% plus lent, ils sont encore limités par le GPU, pas de CPU. Garbage collector est un réel problème, causant aléatoire court gèle si les allocations de mémoire ne sont pas à l'écoute bien.
- Ce n'est pas vrai sur PC; le garbage collector ne un bon travail d'entrer et de sortir, je n'ai jamais eu aucun problème avec elle. Cependant, sur XBox 360 et Zune/Windows-7-Téléphone, le garbage collector n'est pas presque aussi intelligent que sur PC; je n'ai jamais écrit, soit, mais les personnes qui ont dites-moi le garbage collector est un énorme problème.
- href="http://sealedabstract.com/rants/why-mobile-web-apps-are-slow/" >Il y a un excellent article qui explique comment et quand les tables sont lents. Compte tenu de la grande quantité de mémoire suffisante de pression, il peut être lente, même sur un PC. Je ne sais pas le exact exigences de l'AAA, les titres de jeux, mais il n'est pas difficile d'imaginer qu'ils routine d'aller au-delà des limites à l'intérieur desquelles un moderne GC fonctionne bien.
- Bien que les jeux utilisent souvent beaucoup de mémoire, pour la plupart, restent intacts. Surtout avec les écrans de chargement d'un grand nombre de données récupérées à partir du disque dur, le mettre dans la RAM, transféré à la carte vidéo, et certaines d'entre elles peuvent être récupérées. En forçant une collection complète de la GC, après que la phase de chargement, beaucoup de pression peuvent être libérés lors de l'exécution. Générale des performances du jeu, les problèmes viennent du nécessitant beaucoup de puissance de traitement dans des délais petits tout en ayant de rechange dans d'autres. La GC est assez bon à déterminer quand vous avez de rechange, et va essayer de collecter de ces images.
- De ne pas vous contredire, en principe, mais dans la boucle de jeu au cours normal du temps de jeu) il y a donc beaucoup moins de pression que d'une large collection peut s'exécuter sans impact sur l'expérience? En outre, même lorsque la mémoire reste intacte, il doit toujours être disponible. Peut-être que l'utilisation généralisée de la faiblesse des références (à mettre en œuvre un cache, et de le recharger à partir d'une mémoire secondaire lors de la collecte) pourrait aider, mais GCs seulement lorsqu'il y a beaucoup plus de mémoire disponible que dans l'utilisation. Et enfin, la théorie est une chose: dans la pratique, moderne GC de manière fiable, est-ce que vous avez décrit?
- Si vous programmez votre jeu correctement, vous n'aurez pas l'utilisation de la GC à tous. La plupart des types de données et les calculs sont effectués via les structures, les objets persistent pendant toute la durée de vie d'un niveau. Lorsque le niveau est terminée, il suffit de force GC avant de charger le niveau suivant. (En parlant de C# à cet égard)
- J'ai aussi constamment vu que les jeux écrits en C# sont lents. Le croire ou pas, en fait, je regarde pour voir si un jeu a été fait en C# parce que je voudrais essayer de l'éviter pour des raisons de performances, il est si mauvais. La Forêt, 7 Jours À Mourir, Broforce, Plan d'évacuation, Et sur et sur. J'aime VRAIMENT Broforce, donc j'ai mis en place avec elle. C# jeux sont toujours trop lente à mon expérience. Il est très possible que les développeurs ont fait un travail médiocre sur l'optimisation des si. C# est un de mes préférés langues toutefois, mais il est assez lent pour les applications en temps réel
InformationsquelleAutor David The Man
4

En théorie, pour de longues de type serveur d'application, un JIT-langage compilé peut devenir beaucoup plus rapide qu'un nativement compilée en contrepartie. Depuis le JIT langage compilé est généralement la première compilation d'un assez faible niveau intermédiaire de la langue, vous pouvez faire beaucoup de haut niveau optimisations droit au moment de la compilation de toute façon. Le gros avantage vient que l'équipe peut continuer à recompiler les sections de code à la volée comme il devient de plus en plus de données sur la façon dont l'application est utilisée. Il peut organiser le code plus courantes des chemins d'accès à permettre à la branche de prédiction pour réussir aussi souvent que possible. Il peut ré-arranger les blocs de code distincts qui sont souvent appelées ensemble pour garder à la fois dans le cache. Il peut passer plus d'efforts à l'optimisation des boucles internes.

Je doute que cela soit fait par .NET ou de la Jre, mais il a été l'objet de recherches en arrière quand j'étais à l'université, il n'est donc pas déraisonnable de penser que ce genre de choses peuvent trouver leur chemin dans le monde réel à un certain point bientôt.

InformationsquelleAutor Eclipse
4

Les Applications qui requièrent beaucoup d'accès à la mémoire par exemple. manipulation de l'image sont généralement mieux écrit en environnement non géré (C++) réussi (C#). Optimisé boucles internes avec le pointeur de l'arithmétique sont beaucoup plus faciles à avoir le contrôle en C++. En C#, vous pourriez avoir besoin de recourir à la contamination de code pour obtenir même près les mêmes performances.

InformationsquelleAutor Kalle
4

J'ai testé vector en C++ et C# équivalent - List et simple 2d tableaux.

Je suis à l'aide de Visual C#/C++ 2010 Express. Les deux projets sont de simples applications de console, je l'ai testé en standard (pas de réglages personnalisés) release et debug mode.
C# listes de courir plus vite sur mon pc, initialisation de tableau est également plus rapide en C#, les opérations mathématiques sont plus lents.

Je suis en utilisant Intel Core2Duo [email protected], C#.NET 4.0.

Je sais que le vecteur de la mise en œuvre est différente de celle de C# de la liste, mais je voulais juste tester les collections que je voudrais utiliser pour stocker mes objets (et d'être en mesure d'utiliser l'indice de accesseur).

Bien sûr, vous devez effacer de la mémoire (disons pour chaque utilisation de new), mais je voulais garder le code simple.

C++ vecteur de test:
```
static void TestVector()
{
    clock_t start,finish;
    start=clock();
    vector<vector<double>> myList=vector<vector<double>>();
    int i=0;
    for( i=0; i<500; i++)
    {
        myList.push_back(vector<double>());
        for(int j=0;j<50000;j++)
            myList[i].push_back(j+i);
    }
    finish=clock();
    cout<<(finish-start)<<endl;
    cout<<(double(finish - start)/CLOCKS_PER_SEC);
}
```
C# test:
```
private static void TestVector()
{

    DateTime t1 = System.DateTime.Now;
    List<List<double>> myList = new List<List<double>>();
    int i = 0;
    for (i = 0; i < 500; i++)
    {
        myList.Add(new List<double>());
        for (int j = 0; j < 50000; j++)
            myList[i].Add(j *i);
    }
    DateTime t2 = System.DateTime.Now;
    Console.WriteLine(t2 - t1);
}
```
C++ - tableau:
```
static void TestArray()
{
    cout << "Normal array test:" << endl;
    const int rows = 5000;
    const int columns = 9000;
    clock_t start, finish;

    start = clock();
    double** arr = new double*[rows];
    for (int i = 0; i < rows; i++)
        arr[i] = new double[columns];
    finish = clock();

    cout << (finish - start) << endl;

    start = clock();
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < columns; j++)
            arr[i][j] = i * j;
    finish = clock();

    cout << (finish - start) << endl;
}
```
C# - tableau:
```
private static void TestArray()
{
    const int rows = 5000;
    const int columns = 9000;
    DateTime t1 = System.DateTime.Now;
    double[][] arr = new double[rows][];
    for (int i = 0; i < rows; i++)
        arr[i] = new double[columns];
    DateTime t2 = System.DateTime.Now;

    Console.WriteLine(t2 - t1);

    t1 = System.DateTime.Now;
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < columns; j++)
            arr[i][j] = i * j;
    t2 = System.DateTime.Now;

    Console.WriteLine(t2 - t1);

}
```
Temps: (Release/Debug)

C++
- 600 /606 ms tableau init,
- 200 /270 ms tableau à remplir,
- 1sec /13sec vecteur init & remplir.
(Oui, 13 secondes, j'ai toujours des problèmes avec les listes ou les vecteurs en mode de débogage.)

C#:
- 20 /20 ms tableau init,
- 403 /440 ms tableau à remplir,
- 710 /742 ms liste init & remplir.
- J'aimerais voir l'index de l'accesseur en std::list. De toute façon, il faut 37 secondes avec la liste, en mode release. Version sans débogage: 3s liste, 0,3 s vecteur. Probablement référence à délivrer ou de qqch. Exemple: nopaste.pl/12fb
- oui je m'en rends compte que maintenant, d'avoir fait en C#. Peut-être que je vais juste supprimer tout ce qui est de l'histoire...
- ok, je vais supprimer mon commentaire trop.
- Pour des mesures plus précises, vous ne devriez pas être à l'aide de System.DateTime.Now, mais plutôt, le Chronomètre de classe.
- Partie de la raison pour laquelle vous faites une telle lenteur des temps de remplissage pour le vector en C++ est que vous utilisez push_back. Cela a été démontré à de nombreux postes à être plus lent que d'utiliser la méthode ou de l'opérateur []. Pour utiliser l'une de ces méthodes, vous devez utiliser le redimensionnement ou la méthode de réserve. En outre, la raison de votre initialisation est-ce si long pour c++ vecteur cas, c'est que vous êtes forçant une copie ou un opérateur d'affectation [pas sûr dans ce cas) pour initialiser votre c++ vecteur. Pour le tableau en c++, il existe un algorithme qui utilise 2 nouveaux appels plutôt que 5001 et il est plus rapide de l'itération ainsi.
- Je pense que vous n'avez pas fait de c++ dans une manière appropriée. Juste un coup d'œil et trouvé de nombreuses questions. E. g. vector<vector<double>> maliste=vector<vector<double>>()
- Et avez-vous remarqué combien de fois vous avez construit une 2d vectoriel? Et avez-vous l'esprit de faire une réserve() pour accélérer push_back()? Je pense que votre test n'a aucun sens. Et la façon dont vous les mesures les horloges sont loin d'être précis ainsi. Juste mes 2 cents
- vector<vector<double>> maliste=vector<vector<double>>() je vois C# devs qui écrivent C++ le faire tout le temps, c'est LENT et INUTILE, ne faites pas inutile de copies de trucs
- Cela est tout simplement faux. J'obtiens des résultats totalement différents, où C# est plus lente par une marge importante dans les deux tests: 177% pour la matrice, et de 212% pour les vector/liste.
- Wow. Pas sûr de ce que les conclusions qu'on peut tirer de la comparaison des Listes de rapport de redimensionner les tableaux, mais si vous allez utiliser des vecteurs comme cela, vous aurez envie d'apprendre à propos de la réserve (les), mon ami, reserve().
InformationsquelleAutor Wiory
3

Eh bien, ça dépend. Si le byte-code est traduit en code machine (et pas seulement JIT) (je veux dire, si vous exécutez le programme) et si votre programme utilise plusieurs allocations/deallocations il pourrait être plus rapide car la GC algorithme juste besoin d'un pass (théoriquement) à travers l'ensemble de la mémoire une fois, mais c'est normal malloc/realloc, free C/C++ appelle provoque une surcharge sur chaque appel (appel de la surcharge, de la structure des données de la surcharge, le cache 😉 ).

De sorte qu'il est théoriquement possible (aussi pour d'autres GC langues).

Je ne vois pas vraiment l'extrême désavantage de ne pas être en mesure d'utiliser la métaprogrammation avec C# pour la plupart des applications, parce que la plupart des programmeurs ne pas l'utiliser de toute façon.

Un autre grand avantage est que le SQL, comme le LINQ "extension", offre des possibilités pour le compilateur d'optimiser les appels aux bases de données (en d'autres termes, le compilateur pourrait compiler l'ensemble de LINQ pour un "blob" binaire où les fonctions sont intégrées ou de votre utilisation optimisée, mais je suis spéculer ici).
- Tout bon développeur C++ ne sera pas exécuté dans les problèmes que vous décrivez. Seulement de mauvais programmeurs C qui a décidé de frapper les classes de leurs programmes et de C++ ont ces problèmes.
- pour l'amour de dieux, c'est l'âge de 8 ans, OMFGz
- n'hésitez pas à donner une meilleure plus jusqu'à la date de réponse
InformationsquelleAutor Quonux
2

Je suppose qu'il y a des applications écrites en C# en cours d'exécution rapide, ainsi que il y a plus de C++ écrit les applications en cours d'exécution rapide (bien C++, il suffit de plus... et de prendre UNIX trop...)

- la question en effet est - ce qu'est cette chose, les utilisateurs et les développeurs se plaignent ...

Eh bien, à mon humble avis, dans le cas de C#, nous avons de très confort de l'INTERFACE utilisateur, très agréable hiérarchie des bibliothèques, et de l'ensemble de l'interface et du système de CLI. Dans le cas de C++ nous avons des modèles, ATL, COM, MFC et tout inclus de alreadyc écrit et l'exécution de code comme OpenGL, DirectX et ainsi de suite... les Développeurs se plaint de indeterminably ressuscité GC appels en cas de C# (signifie que le programme s'exécute rapidement, et dans un deuxième - bang! il est coincé).

Pour écrire du code en C# très simple et rapide (ne pas oublier que l'augmentation de risques d'erreurs.
Dans le cas de C++, les développeurs se plaint de fuites de mémoire, - des moyens écrase, les appels entre les Dll, ainsi que de "l'enfer des DLL" - problème avec le soutien et les bibliothèques de remplacement par des nouvelles...

Je pense que plus de compétences que vous avez dans le langage de programmation, plus de qualité (et la vitesse) permettra de caractériser votre logiciel.

InformationsquelleAutor bgee
2

Je voudrais le mettre de cette façon: les programmeurs qui écrivent plus vite code, sont ceux qui sont le plus informés de ce qui rend les machines actuelles aller vite, et d'ailleurs ils sont aussi ceux qui utilisent un outil approprié qui permet à pour les précise de bas niveau et déterministe de techniques d'optimisation. Pour ces raisons, ces personnes sont celles qui utilisent le C/C++ plutôt que de C#. J'irais même jusqu'à affirmer cela comme un fait.
- Notch codé minecraft assez rapide compte tenu de la quantité de données qu'il est de la manipulation. Aussi, il a codé la plupart du temps seul dans un relativement court laps de temps, quelque chose qui aurait été pratiquement impossible en C++. Je suis d'accord avec l'optimisation des techniques de bien-si vous avez le supplément 10x dev temps à passer votre code s'exécute deux fois plus vite, c'est probablement la peine.
InformationsquelleAutor Johan Boulé
1

> Après tout, les réponses doivent être quelque part, n'est-ce pas? 🙂

Euh, non.

Que plusieurs réponses noté, la question est sous-spécifié d'une façon qui attire les questions en réponse, pas de réponses. Pour ne prendre qu'un moyen:
- la question débordait de la langue avec la langue de l'implémentation de ce programme C est à la fois 2,194 fois plus lent et 1.17 fois plus rapide que ce programme C# - nous vous demander: Qui les implémentations de langue?
Et puis quels programmes? Quelle machine? Quel système d'exploitation? Quel ensemble de données?
- Je suis entièrement d'accord. Je me demande pourquoi les gens attendent une réponse précise (63.5%), quand il pose une question d'ordre général. Je ne pense pas qu'il n'y a pas de réponse générale à cette question.
- Je sais ce que tu veux dire, mais votre dernière phrase sonne comme des ongles sur un tableau à craie à n'importe quel programmeur.
- ouais, désolé c'est une faute de frappe, merci de remarquer.
- Cela ne semble pas répondre à la question, et se lit plus comme un commentaire ou coup de gueule.
InformationsquelleAutor
1

Si je ne me trompe pas, C# modèles sont déterminés au moment de l'exécution. Ce doit être plus lent que le temps de compilation des templates de C++.

Et quand vous prenez tous les autres au moment de la compilation des optimisations mentionné par de nombreux autres, ainsi que le manque de sécurité qui n'a, en effet, signifie plus de vitesse...

Je dirais que C++ est le choix évident en termes de vitesse brute et le minimum de consommation de mémoire. Mais cela signifie aussi plus de temps pour développer le code et de s'assurer que vous ne sont pas de fuite de mémoire ou de causer un pointeur null exceptions.

Verdict:
- C#: un développement plus Rapide, plus lent exécuter
- C++: développement Lent, plus rapide à exécuter.
InformationsquelleAutor HumbleWebDev
0

Cela dépend vraiment de ce que vous voulez accomplir dans votre code. J'ai entendu dire que c'est juste des trucs de la légende urbaine qu'il n'y a aucune différence de performances entre les VB.NET, C# et C++. Cependant, j'ai trouvé, au moins dans les comparaisons de chaînes, que le C++ bat le pantalon large de C#, qui bat le pantalon large de VB.NET.

J'ai pas fait des comparaisons exhaustives dans la complexité algorithmique entre les langues. Je suis aussi juste en utilisant les paramètres par défaut dans chacune des langues. Dans VB.NET je suis en utilisant les paramètres d'exiger la déclaration des variables, etc. Voici le code que j'utilise pour le C++: (Comme vous pouvez le voir, ce code est assez simple). Je suis en cours d'exécution de même dans les autres langues dans Visual Studio 2013 avec .NET 4.6.2.
```
#include "stdafx.h"

using namespace System;
using namespace System::Diagnostics;

bool EqualMe(String^ first, String^ second)
{
    return first->Equals(second);
}
int main(array<String ^> ^args)
{
    Stopwatch^ sw = gcnew Stopwatch();
    sw->Start();
    for (int i = 0; i < 100000; i++)
    {
        EqualMe(L"one", L"two");
    }
    sw->Stop();
    Console::WriteLine(sw->ElapsedTicks);
    return 0;
}
```
InformationsquelleAutor Charles Owen
0

Il existe des différences importantes entre C# et C++ sur l'aspect performance:
- C# est GC /tas base. L'affectation et de la GC lui-même est au-dessus que la non localité de l'accès à la mémoire
- C++ optimiseurs sont devenus très bons au fil des ans. Les compilateurs JIT ne peut pas atteindre le même niveau depuis ils n'ont guère le temps de compilation et de ne pas voir la portée mondiale
D'ailleurs que programmeur compétence joue également un rôle. J'ai vu des mauvais code C++ où les classes où sont passées par valeur comme argument dans tous les sens. Vous pouvez réellement faire de pire en C++ si vous ne payez pas attention.

InformationsquelleAutor gast128
-10

Inspiré par la présente, j'ai fait un test rapide avec 60 pour cent de la commune instruction nécessaire dans la plupart des programmes.

Voici le code C#:
```
for (int i=0; i<1000; i++)
{
    StreamReader str = new StreamReader("file.csv");
    StreamWriter stw = new StreamWriter("examp.csv");
    string strL = "";
    while((strL = str.ReadLine()) != null)
    {
        ArrayList al = new ArrayList();
        string[] strline = strL.Split(',');
        al.AddRange(strline);
        foreach(string str1 in strline)
        {
            stw.Write(str1 + ",");
        }
        stw.Write("\n");
    }
    str.Close();
    stw.Close();
}
```
Chaîne de tableau et de liste de tableaux sont utilisé à dessein, afin d'inclure ces instructions.

Voici le code c++:
```
for (int i = 0; i<1000; i++)
{
    std::fstream file("file.csv", ios::in);
    if (!file.is_open())
    {
        std::cout << "File not found!\n";
        return 1;
    }

    ofstream myfile;
    myfile.open ("example.txt");
    std::string csvLine;

    while (std::getline(file, csvLine))
    {
        std::istringstream csvStream(csvLine);
        std::vector csvColumn;
        std::string csvElement;

        while( std::getline(csvStream, csvElement, ‘,’) )
        {
            csvColumn.push_back(csvElement);
        }

        for (std::vector::iterator j = csvColumn.begin(); j != csvColumn.end(); ++j)
        {
            myfile << *j << ", ";
        }

        csvColumn.clear();
        csvElement.clear();
        csvLine.clear();
        myfile << "\n";
    }
    myfile.close();
    file.close();
}
```
La taille du fichier d'entrée que j'ai utilisé était de 40 KO.

Et voici le résultat -
- Code C++ couru en 9 secondes.
- De code C#: 4 secondes!!!
Oh, mais ce qui était sur Linux... Avec C# en cours d'exécution sur Mono... Et C++ avec g++.

OK, c'est ce que je suis sur Windows – Visual Studio; 2003:
- De code C# a couru en 9 secondes.
- Code C++ – horrible 370 secondes!!!
- Vous êtes à l'aide de différentes structures de données et le code de bibliothèque, bien que "370 secondes" indique quelque chose d'horrible - vous n'êtes pas en cours d'exécution dans le débogueur par hasard êtes-vous? Je soupçonne que la performance du CSV de la bibliothèque que vous utilisez est plus intéressant que le rendement de la langue que vous utilisez. Je m'interroge sur l'utilisation d'un vecteur dans ce contexte, et en ce que des optimisations que vous avez utilisé. En outre, il est largement connu que iostreams (en particulier, le "monfichier << *j << ", ";") est beaucoup plus lent que les autres méthodes d'écriture dans le fichier, pour au moins certaines communes des implémentations.
- Enfin, vous êtes en train de faire plus de travail dans la version C++. (Pourquoi êtes-vous de compensation de la csvColumn, csvElement et csvLines?)
- Chaque itération de la boucle while va détruire et reconstruire un std::istream et un std::vector et un std::string. L'tandis que le corps est hors de portée de chaque itération, toutes ces variables à l'intérieur de la alors que de la portée va détruire et de construire à chaque itération.
- de la porte de la lecture de votre code c++ que vous essayez de le copier à partir d'un fichier vers un autre fichier. Au lieu d'utiliser les interactions complexes entre les flux de fichiers, des cordes, des vecteurs et de la chaîne de flux, vous pouvez avoir copié le fichier d'entrée du flux vers le fichier de sortie de flux. Cela aurait permis d'économiser beaucoup de temps et de mémoire.
- pour faire des tests de vitesse, de tester des choses en memmory ne recevez pas d'e / s de disque, unsless vos tests sur le dernier disque SSD et de ses dévoués de la performance de l'application. Comme les ordinateurs constamment écrire sur le disque, même si vous n'avez pas de toucher le clavier.
- Je dirais que la façon la plus équitable de comparer les langues pourrait être d'utiliser leurs propres outils, et de réaliser les opérations dans presque exactement de la même manière. Peut-être à l'aide de chaque langue par défaut de la chaîne.fonction de répartition et dans la lecture ligne par ligne le défaut aurait été mieux.
- Avez-vous même de compiler avec les optimisations activées? 9 s vs 370 sec semble peu probable, à moins que MSVC manqué l'optimisation de certains très coûteux trucs que g++ trouvé.
InformationsquelleAutor rks

Vous devez vous connecter pour publier un commentaire.

Total des temps d'Exécution: C#: 289ms, C++ 152ms (environ 90% plus rapide)