Combien de temps le c++ est-il plus rapide que le C#?

ou est-ce l'inverse?

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

a pensé que l'un d'entre vous pourrait expliquer ces différences en détail ou me pointer au bon endroit pour des informations à ce sujet.

197
demandé sur Peter Mortensen 2008-09-26 12:57:46

27 réponses

il n'y a pas de raison stricte pour qu'un langage basé sur le bytecode comme C# ou Java qui a un JIT ne puisse pas être aussi rapide que du code C++. Cependant, le code C++ était significativement plus rapide pendant longtemps, et l'est encore aujourd'hui dans de nombreux cas. Ceci est principalement dû au fait que les optimisations JIT les plus avancées sont compliquées à mettre en œuvre, et que les optimisations vraiment cool n'arrivent que maintenant.

donc C++ est plus rapide, dans de nombreux cas. Mais ce n'est qu'une partie de la réponse. Les cas où C++ est en fait plus rapide, sont des programmes hautement optimisés, où les programmeurs experts complètement optimisé l'enfer hors du code. Non seulement cela prend beaucoup de temps (et donc coûte cher), mais cela conduit aussi souvent à des erreurs dues à des optimisations excessives.

d'un autre côté, le code dans les langues interprétées est plus rapide dans les versions ultérieures de l'exécution (.NET CLR ou Java VM), sans que vous ne fassiez quoi que ce soit. Et il ya beaucoup d'optimisations utiles compilateurs JIT peuvent faire qui sont tout simplement impossible dans les langues avec des pointeurs. En outre, certains font valoir que la collecte des ordures devrait généralement être aussi rapide ou plus rapide que la gestion manuelle de la mémoire, et dans de nombreux cas, il est. Vous pouvez généralement implémenter et réaliser tout cela en C++ ou C, mais cela va être beaucoup plus compliqué et sujet à des erreurs.

comme L'a dit Donald Knuth, "l'optimisation prématurée est la racine de tout le mal". Si vous êtes vraiment sûr que votre application se composera principalement de très performances critiques 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 tous les autres cas, concentrez-vous d'abord sur la mise en œuvre correcte de votre application dans la langue qui vous convient le mieux, puis trouvez des goulots d'étranglement de performance si elle est trop lente, et ensuite pensez à la façon d'optimiser le code. Dans le pire des cas, vous pourriez avoir besoin d'appeler au code C à travers une interface de fonction étrangère, ont toujours la capacité d'écrire des parties critiques dans un langage de niveau inférieur.

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

donner des pourcentages réels d'avantages de vitesse est impossible, cela dépend en grande partie de votre code. Dans de nombreux cas, la mise en œuvre du langage de programmation n'est même pas le goulot d'étranglement. Prenez les points de référence à http://benchmarksgame.alioth.debian.org / avec beaucoup de scepticisme, car ceux-ci testent largement le code arithmétique, qui n'est probablement pas similaire à votre code du tout.

286
répondu Martin Probst 2016-05-26 23:09:11

C# peut ne pas être plus rapide, mais il vous/moi plus rapide. C'est la mesure la plus importante pour ce que je fais. :)

172
répondu mattlant 2016-07-17 18:29:41

c'est cinq oranges plus rapide. Ou plutôt: il ne peut y avoir de réponse globale (correcte). C++ est un langage compilé statiquement (mais il y a aussi l'optimisation guidée par le profil), C# fonctionne avec l'aide d'un compilateur JIT. Il y a tellement de différences que l'on ne peut répondre à des questions comme "combien plus vite", pas même en donnant des ordres de grandeur.

75
répondu Konrad Rudolph 2008-09-26 09:05:32

d'après mon expérience (et j'ai beaucoup travaillé avec les deux langues), le principal problème avec C# par rapport à C++ est la consommation élevée de mémoire, et je n'ai pas trouvé de bonne façon de le contrôler. C'est la consommation de mémoire qui finit par ralentir le logiciel .NET.

un autre facteur est que le compilateur JIT ne peut pas se permettre trop de temps pour faire des optimisations avancées, parce qu'il fonctionne à l'exécution, et l'utilisateur final le remarquerait si cela prend trop de temps. Sur l'autre main, un compilateur C++ a tout le temps dont il a besoin pour faire des optimisations au moment de la compilation. Ce facteur est beaucoup moins significatif que la consommation de mémoire, IMHO.

53
répondu Nemanja Trifunovic 2008-09-26 14:02:27

je vais commencer par être en désaccord avec une partie de la réponse acceptée (et bien accueillie) à cette question en disant:

il y a en fait beaucoup de raisons pour lesquelles le code Jitté fonctionnera plus lentement qu'un c++ correctement optimisé (ou un autre langage sans dépassement de temps d'exécution)) programme incluant:

  • par définition, les cycles de calcul consacrés au JITting du code à l'exécution ne peuvent pas être utilisés dans le programme exécution.

  • tous les chemins chauds dans le JITter seront en concurrence avec votre code pour l'instruction et le cache de données dans le CPU. Nous savons que le cache domine quand il s'agit de performances et les langages natifs comme C++, par définition, n'ont pas ce type de prétention.

  • le budget temps d'un optimiseur de temps est nécessairement beaucoup plus limité que celui d'une compilation-temps optimizer's (comme un autre commentateur l'a souligné)

résultat final: finalement, vous will presque certainement être en mesure de créer une implémentation plus rapide en C++ que vous ne le pourriez en C# .

maintenant, avec cela dit, comment beaucoup plus rapide n'est vraiment pas quantifiable, car il ya trop de variables: la tâche, le domaine de problèmes, le matériel, la qualité des mises en œuvre, et beaucoup d'autres facteurs. Vous aurez effectué des tests sur votre scénario pour décider si l'effort supplémentaire et la complexité en vaut la peine.

c'est un sujet très long et complexe, mais je pense qu'il vaut la peine de mentionner par souci d'exhaustivité que l'optimiseur d'exécution de C#est excellent, et est capable d'effectuer certaines optimisations dynamiques à l'exécution qui ne sont tout simplement pas disponibles pour C++ avec son optimiseur de compilation (statique). Malgré cela, l'avantage est encore typiquement profond dans la Cour de l'application native, mais l'optimiseur dynamique est la raison pour le " presque certainement" qualificatif, donné ci-dessus.

--

en ce qui concerne le rendement relatif, j'ai également été troublé par les chiffres et les discussions que j'ai vus dans d'autres réponses, alors j'ai pensé que je pourrais intervenir et en même temps, fournir un certain soutien pour les déclarations que j'ai faites ci-dessus.

Une grande partie du problème avec ceux les repères que vous ne pouvez pas écrire de code C++ comme si vous avez été écrit en C# et s'attendre à obtenir des résultats représentatifs (par exemple. effectuer des milliers d'attributions de mémoire en C++ va vous donner des nombres terribles.)

à la place, j'ai écrit un peu plus de code C++ idiomatique et comparé avec le C# code @Wiory fourni. Les deux principaux changements que j'ai apportés au code c++ étaient:

1) vecteur utilisé:: reserve()

2) a aplati le tableau 2d à 1D à achieve better cache locality (contigu block)

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);
}

(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);
}

(Libération): Init: 398µs (oui, c'est microsecondes), le Remplir: 152ms

Course Totale temps: c#: 289ms, c++ 152ms (environ 90% plus rapide)

Observations

  • changer l'implémentation C# pour la même implémentation 1D produit Init: 40ms, Fill: 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 "régulier" code dans les deux langues.

  • il est (peut-être) étonnamment facile d'obtenir de mauvaises performances en C++; nous l'avons vu avec des performances de vecteurs sans réserve. Et il y a beaucoup d'écueils comme celui-ci.

  • C la performance de C#est assez étonnante quand on considère tout ce qui se passe à l'exécution. Et que le rendement est relativement facile à accès.

  • plus anecdotique données comparant la performance de C++ et C#: https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=gpp&lang2=csharpcore

le résultat est que C++ Vous donne beaucoup plus de contrôle sur la performance. Tu veux utiliser un pointeur? Une référence? La pile de la mémoire? Tas? Polymorphisme dynamique ou éliminer le temps d'exécution au-dessus d'un vtable avec polymorphisme statique (via templates/CRTP)? En C++, vous devez... er, 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 ou si vous avez besoin de ce contrôle, parce que même pour l'exemple trivial ci-dessus, vous pouvez voir que bien qu'il y ait une amélioration significative de la performance, il faut un investissement plus profond pour y accéder.

48
répondu U007D 2017-12-02 14:02:44

un scénario particulier où C++ a toujours le dessus (et le sera, pour les années à venir) se produit lorsque les décisions polymorphiques peuvent être prédéterminées au moment de la compilation.

en général, l'encapsulation et la prise de décision différée est une bonne chose parce qu'elle rend le code plus dynamique, plus facile à adapter à l'évolution des besoins et plus facile à utiliser comme cadre. C'est pourquoi la programmation orientée objet en C# est très productive et peut être généralisée sous le terme "généralisation." Malheureusement, ce type particulier de généralisation a un coût à l'exécution.

habituellement, ce coût n'est pas important, mais il y a des applications où les appels de méthodes virtuelles et la création d'objets peuvent faire une différence (d'autant plus que les méthodes virtuelles empêchent d'autres optimisations telles que l'affichage d'appels de méthodes). C'est là que C++ a un énorme avantage parce que vous pouvez utiliser des gabarits pour obtenir un autre type de généralisation qui a Non impact sur l'exécution mais n'est pas nécessairement moins polymorphe que L'OOP. En fait, tous les mécanismes qui constituent la POO peuvent être modélisés en utilisant seulement des techniques de modèle et de résolution de temps de compilation.

dans de tels cas (et il est vrai qu'ils sont souvent limités à des domaines à problèmes spéciaux), C++ gagne contre C# et des langues comparables.

31
répondu Konrad Rudolph 2008-09-26 14:08:05

C++ (ou C d'ailleurs) vous donne un contrôle fin sur vos structures de données. Si vous voulez mordre-twiddle vous avez cette option. Les grandes applications gérées Java ou .NET (OWB, Visual Studio 2005 ) qui utilisent les structures de données internes des bibliothèques Java/.NET transportent les bagages avec elles. J'ai vu des sessions de designer OWB utilisant plus de 400 Mo de RAM et des appels d'offres pour cube ou ETL de conception entrer dans les 100'S de MB aussi bien.

sur une charge de travail prévisible (comme la plupart des benchmarks qui répètent un processus plusieurs fois) un JIT peut vous obtenir un code qui est suffisamment bien optimisé pour qu'il n'y ait aucune 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. Lorsqu'une application est chargée en mémoire, l'utilisation du cache sera moins efficace. Les erreurs de Cache sur les CPU modernes sont assez chères. Où C ou c++ gagne vraiment est où vous pouvez optimiser votre utilisation des structures de données pour jouer correctement avec le cache CPU.

17
répondu ConcernedOfTunbridgeWells 2016-07-17 18:34:18

pour les graphiques la classe standard C # Graphics est beaucoup plus lente que GDI accessible via C/C++. Je sais que cela n'a rien à voir avec le langage en soi, plus avec la plate-forme total .NET, mais le graphisme est ce qui est offert au développeur en tant que remplacement de GDI, et ses performances sont si mauvaises que je n'oserais même pas faire du graphisme avec.

nous avons un benchmark simple que nous utilisons pour voir à quelle vitesse une bibliothèque graphique est, et qui est tout simplement le dessin de lignes aléatoires dans une fenêtre. C++ / GDI est toujours snappy avec 10000 lignes tandis que c#/Graphics a de la difficulté à faire 1000 en temps réel.

16
répondu QBziZ 2008-09-26 20:13:41

la collecte des ordures est la principale raison pour laquelle Java# ne peut pas être utilisé pour les systèmes en temps réel.

  1. quand le GC aura-t-il lieu?

  2. combien de temps cela prendra-t-il?

C'est non-déterministe.

12
répondu 2008-12-08 13:46:02

nous avons dû déterminer si C# était comparable à C++ en performance et j'ai écrit quelques programmes de test pour cela (en utilisant Visual Studio 2005 pour les deux langues). Il s'est avéré que sans collecte de déchets et en considérant seulement le langage (pas le framework) C# A Fondamentalement la même performance que C++. L'allocation de mémoire est beaucoup plus rapide en C# qu'en C++ et C# a un léger avantage dans le déterminisme lorsque la taille des données est augmentée au-delà des limites de la ligne de cache. Cependant, tout cela a eu finalement à payer et il y a un coût énorme sous la forme de résultats non déterministes de performance pour C# en raison de la collecte des ordures.

11
répondu ILoveFortran 2008-12-29 22:26:57

comme d'habitude, cela dépend de l'application. Il y a des cas où C# est probablement beaucoup plus lent, et d'autres où C++ est 5 à 10 fois plus rapide, surtout dans les cas où les opérations peuvent être simulées facilement.

9
répondu Dark Shikari 2008-09-26 09:16:49

je sais que ce n'est pas ce que vous demandiez, mais C# est souvent plus rapide à écrire que C++, qui est un gros bonus dans un cadre commercial.

9
répondu Kramii 2008-09-26 14:06:25

. les langages réseau peuvent être aussi rapides que le code C++, ou même plus rapides, mais le code C++ aura un débit plus constant que le. le runtime de réseau doit s'arrêter pour GC , même s'il est très intelligent au sujet de ses pauses.

donc si vous avez un code qui doit être exécuté rapidement sans aucune pause, .NET va introduire la latence à un moment donné , même si vous êtes très prudent avec le mode D'exécution GC.

7
répondu Florian Doyon 2016-07-17 18:45:30

C / C++ peut donner de meilleurs résultats dans les programmes où il y a soit de grands tableaux, soit de lourdes boucles/itérations sur des tableaux (de n'importe quelle taille). C'est la raison pour laquelle les graphiques sont généralement beaucoup plus rapides en C/C++, parce que les opérations de réseau lourd sous-tendent presque toutes les opérations graphiques. .NET est notoirement lent dans les opérations d'indexage des réseaux en raison de tous les contrôles de sécurité, et cela est particulièrement vrai pour les réseaux multidimensionnels (et, oui, les réseaux rectangulaires C# sont encore plus lents que les réseaux jaggés C# tableau.)

les bonus de C/C++ sont plus prononcés si vous vous en tenez directement aux pointeurs et évitez Boost, std::vector et autres conteneurs de haut niveau, ainsi que inline chaque petite fonction possible. Utilisez les tableaux de la vieille école dans la mesure du possible. Oui, vous aurez besoin de plus de lignes de code pour accomplir la même chose que vous avez fait en Java ou C# car vous évitez les conteneurs de haut niveau. Si vous avez besoin d'un tableau de taille dynamique, vous aurez juste besoin de se rappeler de coupler votre new T[] avec une déclaration delete[] (ou utilisez std::unique_ptr )-le prix pour la vitesse supplémentaire est que vous devez coder plus soigneusement. Mais en échange, vous vous débarrassez vous-même des frais généraux de la mémoire gérée / collecteur de déchets, qui peut facilement être 20% ou plus du temps d'exécution des programmes fortement orientés objet dans Java et .NET, ainsi que ces coûts d'indexation de tableau de mémoire gérée massive. Les applications C++ peuvent également bénéficier de quelques commutateurs de compilateurs nifty dans certains cas spécifiques.

je suis un programmeur expert en C, C++, Java, et C#. J'ai eu récemment l'occasion rare d'implémenter le même programme algorithmique dans les 3 dernières langues. Le programme a eu beaucoup de mathématiques et multi-dimensional array opérations. J'ai fortement optimisé ceci dans les 3 langues. les résultats étaient typiques de ce que je vois habituellement dans des comparaisons moins rigoureuses: Java était environ 1,3 x plus rapide que C# (la plupart des JVM sont plus optimisées que le CLR), et le pointeur brut C++ la version est arrivée environ 2,1 fois plus vite que C#. notez que le programme C# n'utilisait que du code de sécurité-à mon avis, vous pouvez aussi bien le coder en C++ avant d'utiliser le mot-clé unsafe .

de peur que quelqu'un pense que j'ai quelque chose contre C#, je terminerai en disant que C# est probablement ma langue préférée. C'est le langage de développement le plus logique, intuitif et rapide que j'ai rencontré jusqu'à présent. Je fais tout mon prototypage en C#. Le langage C # a beaucoup de petits, subtils avantages par rapport à Java (oui, je sais que Microsoft a eu la chance de corriger beaucoup de défauts de Java en entrant dans le jeu en retard et sans doute en copiant Java). Un Toast à la classe Calendar de Java? Si Microsoft fait un effort réel pour optimiser le CLR et le .NET JITter, C# pourrait sérieusement prendre la relève. Je suis honnêtement surpris qu'ils ne l'aient pas déjà fait-ils ont fait tellement de choses dans le langage C#, pourquoi ne pas le suivre avec des optimisations de compilateurs percutantes? Peut-être que si nous supplions tous.

6
répondu Special Sauce 2016-01-01 00:50:29

> D'après ce que j'ai entendu ...

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

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

Une façon serait de demander preuves .

quand quelqu'un prétend "il y a des zones dans lesquelles C# s'avère être plus rapide que C++" demandez-leur pourquoi ils disent que , demandez-leur de vous montrer les mesures, demandez-leur de vous montrer les programmes. Parfois, ils n'ont tout simplement fait une erreur. Parfois, vous découvrirez qu'ils expriment simplement une opinion plutôt que de partager quelque chose qu'ils peuvent montrer être vrai.

souvent l'information et l'opinion être mêlé à ce que les gens prétendent, et vous devrez essayer de déterminer qui est qui. Par exemple, des réponses dans ce forum:

  • "prenez le benchmarks à http://shootout.alioth.debian.org / avec beaucoup de scepticisme, comme l' ces tests consistent essentiellement à tester le code arithmétique, ce qui n'est probablement pas similaire à votre code."

    demandez-vous si vous êtes vraiment comprendre ce qu' " ces essais en grande partie le code arithmétique " signifie, Et alors demandez-vous si l'auteur a effectivement montré que sa demande est vrai.

  • "c'est un test plutôt inutile, car cela dépend vraiment de la qualité les programmes individuels 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 les programmes non optimisés est 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!

6
répondu Peter Mortensen 2016-07-17 18:37:22

en théorie, pour une application de type serveur de longue durée, un langage compilé par JIT peut devenir beaucoup plus rapide qu'un équivalent compilé nativement. Étant donné que le langage compilé JIT est généralement compilé pour la première fois dans un langage intermédiaire de niveau assez bas, vous pouvez faire beaucoup d'optimisations de haut niveau juste au moment de la compilation de toute façon. Le grand avantage vient dans le fait que le JIT peut continuer à recompiler des sections de code à la volée comme il obtient de plus en plus de données sur la façon dont le l'application est utilisée. Il peut organiser les chemins de code les plus communs pour permettre à la prédiction de branche de réussir aussi souvent que possible. Il peut réarranger des blocs de code séparés qui sont souvent appelés ensemble pour les garder tous les deux dans le cache. Il peut dépenser plus d'efforts à optimiser les boucles internes.

je doute que cela soit fait par .NET ou l'un des JREs, mais il était en cours de recherche quand j'étais à l'université, il n'est donc pas déraisonnable de penser que ce genre de choses peuvent trouver leur loin dans le monde réel à un moment donné bientôt.

5
répondu Eclipse 2008-09-27 16:38:38

pour les problèmes "étonnamment parallèles", lors de L'utilisation D'Intel TBB et D'OpenMP sur C++, j'ai observé une augmentation des performances d'environ 10x par rapport à des problèmes similaires (mathématiques pures) avec C# et TPL. SIMD est un domaine où C# ne peut pas rivaliser, mais j'ai également eu l'impression que TPL a un frais généraux importants.

cela dit, Je n'utilise le c++ que pour les tâches critiques où je sais que je serai capable de multithread et d'obtenir des résultats rapidement. Pour tout le reste, C# (et de temps en temps F#) est très bien.

5
répondu Dmitri Nesteruk 2011-05-13 12:38:29

c'est une question extrêmement vague sans vraies réponses définitives.

par exemple; je préfère jouer à des jeux 3D créés en C++ qu'en C#, car la performance est certainement bien meilleure. (Et je sais de XNA, etc., mais il ne s'approche pas de la vraie chose).

, d'autre part, comme mentionné précédemment, vous devez développer dans un langage qui permet de faire ce que vous voulez rapidement, puis, si nécessaire, optimiser.

5
répondu David The Man 2016-07-17 18:35:07

Applications qui nécessitent un accès intensif à la mémoire, par exemple: la manipulation d'image est habituellement mieux écrite dans un environnement non géré (C++) que dans un environnement géré (c#). Les boucles internes optimisées avec arithmétique pointer sont beaucoup plus faciles à contrôler en C++. Dans C# vous pourriez avoir besoin de recourir au code dangereux pour même obtenir près de la même performance.

4
répondu Kalle 2008-12-11 13:54:37

j'ai testé vector dans des matrices C++ et C# equivalent - List et des matrices 2D simples.

j'utilise Visual C#/C++ 2010 Express editions. Les deux projets sont de simples applications de console, je les ai testées en version standard (pas de paramètres personnalisés) et en mode de débogage. Les listes C# s'exécutent plus vite sur mon pc, l'initialisation des tableaux est aussi plus rapide en C#, les opérations mathématiques sont plus lentes.

j'utilise Intel Core2Duo P8600@2.4GHz, C# - .NET 4.0.

je sais que l'implémentation vectorielle est différente de C# list, mais je voulais juste tester les collections que j'utiliserais pour stocker mes objets (et pouvoir utiliser l'accesseur d'index).

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 de la liste:

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);

}

De Temps: (Release/Debug)

C++

  • 600 / 606 ms array init,
  • 200 / 270 ms tableau à remplir,
  • 1sec /13sec vecteur d'initialisation et de remplissage.

(Oui, 13 secondes, j'ai toujours des problèmes avec les listes ou les vecteurs en mode de débogage.)

c#:

  • 20 / 20 ms array init,
  • 403 / 440 ms tableau à remplir,
  • 710 / 742 ms liste d'initialisation et de remplissage.
4
répondu Wiory 2014-08-24 23:15:39

ç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 beaucoup d'allocations/désallocations il pourrait être plus rapide parce que l'algorithme GC a juste besoin d'un passage (en théorie) à travers toute la mémoire une fois, mais les appels normaux malloc/realloc/C/C libre++ provoque un overhead sur chaque appel (Call-overhead, data-structure overhead, cache manque ;) ).

donc c'est théoriquement possible (même pour les autres langues GC).

Je ne vois pas vraiment l'inconvénient extrême de ne pas pouvoir utiliser metaprogrammation avec C# pour la plupart des applications, parce que la plupart des programmeurs ne l'utilisent pas de toute façon.

un autre grand avantage est que le SQL, comme le LINQ "extension", fournit des possibilités pour le compilateur d'optimiser les appels à bases de données (en d'autres termes, le compilateur pourrait compiler L'ensemble de LINQ à un binaire "blob" où les fonctions appelées sont enlignées ou pour votre usage optimisé, mais je spécule ici).

3
répondu Quonux 2016-07-17 18:49:59

je suppose qu'il y a des applications écrites en C# qui s'exécutent rapidement, ainsi qu'il y a plus d'applications écrites en C++ qui s'exécutent rapidement (et bien C++ Un peu plus ancien... et prenez UNIX aussi...)

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

Eh bien, IMHO, dans le cas de C# nous avons très confort UI, très belle hiérarchie des bibliothèques, et tout le système d'interface de CLI. Dans le cas de C++ nous avons des templates, ATL, COM, MFC et tout le shebang d'alreadyc écrit et exécute le code comme OpenGL, DirectX et ainsi de suite... Les développeurs se plaignent de l'augmentation indéterminée des appels GC en cas de C# (signifie que le programme tourne rapidement, et en une seconde - bang! il est coincé).

Écrire du code en C # très simple et rapide (sans oublier que cela augmente aussi les risques d'erreurs). En cas de C++, les développeurs se plaignent de fuites de mémoire, - signifie écrasements, appels entre DLLs, ainsi que de "DLL enfer" - problème de soutien et de remplacement bibliothèques par les plus récentes...

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

2
répondu bgee 2008-09-26 17:06:31

je le dirais de cette façon: les programmeurs qui écrivent du code plus rapide, sont ceux qui sont les plus informés de ce qui fait que les machines actuelles vont vite, et d'ailleurs ils sont aussi ceux qui utilisent un outil approprié qui permet des techniques précises d'optimisation de bas niveau et déterministe. Pour ces raisons, ces gens sont ceux qui utilisent C/C++ plutôt que C#. J'irais même jusqu'à affirmer cela comme un fait.

2
répondu Johan Boulé 2016-05-07 23:15:55

si Je ne me trompe pas, C# templates sont déterminés à l'exécution. Cela doit être plus lent que les modèles de temps de compilation de C++.

et quand vous prenez en compte toutes les autres optimisations du temps de compilation mentionnées par tant d'autres, ainsi que le manque de sécurité qui signifie, en effet, plus de vitesse...

je dirais que C++ est le choix évident en termes de vitesse brute et de consommation minimale de mémoire. Mais cela se traduit également par Plus de temps à développer le code et s'assurer que vous n'êtes pas en train de perdre de la mémoire ou de causer des exceptions au pointeur nul.

Verdict:

  • C#: un développement plus Rapide, plus lent run

  • C++: développement lent, course plus rapide.

2
répondu HumbleWebDev 2016-07-17 18:53:53

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

Euh, non.

comme plusieurs réponses l'ont fait remarquer, la question Est sous-spécifiée d'une manière qui invite des questions en réponse, pas des réponses. Pour ne prendre qu'un chemin:

et puis quels programmes? Quelle machine? Quel système d'exploitation? Quel ensemble de données?

1
répondu Peter Mortensen 2016-07-17 18:39:00

Cela dépend vraiment de ce que vous voulez accomplir dans votre code. J'ai entendu dire que c'est juste une légende urbaine qu'il y a une différence de performance entre VB.NET, C# et managed C++. Cependant, j'ai trouvé, au moins dans les comparaisons de cordes, que le C++ managé bat le pantalon de C#, qui à son tour bat le pantalon de VB.NET.

Je n'ai en aucun cas fait de comparaisons exhaustives dans la complexité algorithmique entre les langues. Je suis également en utilisant simplement les paramètres par défaut dans chacune des langues. En VB.NET j'utilise les paramètres pour 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). J'exécute la même chose 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;
}
0
répondu Charles Owen 2018-04-07 06:37:13

inspiré par cela, j'ai fait un test rapide avec 60 pour cent de l'instruction commune 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 caractères array et arraylist sont utilisés expressément pour 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 KB.

et voici le résultat -

  • code C++ couru en 9 secondes.
  • code C#: 4 secondes!!!

Oh, mais C'était sous Linux... Avec C # tournant sur Mono ... Et C++ avec g++.

OK, c'est ce que J'ai obtenu sur Windows – Visual Studio 2003 :

  • code C# a couru en 9 secondes.
  • code C++ – horrible 370 secondes!!!
-11
répondu rks 2016-07-17 18:43:34