Combien plus rapide est C ++ que C #?

Ou est-ce maintenant l'inverse?

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

Je pensais que vous pourriez expliquer ces différences en détail ou me diriger vers le bon endroit pour obtenir des informations à ce sujet.

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

C ++ est donc 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ù des programmeurs experts ont complètement optimisé le code. Non seulement cela prend beaucoup de temps (et donc est cher), mais cela entraîne aussi généralement des erreurs dues à des optimisations excessives.

D'un autre côté, le code dans les langages interprétés devient plus rapide dans les versions ultérieures du runtime (.NET CLR ou Java VM), sans que vous ne fassiez rien. Et il y a beaucoup d'optimisations utiles que les compilateurs JIT peuvent faire qui sont tout simplement impossibles dans les langages avec des pointeurs. En outre, certains soutiennent que la récupération de place doit généralement être aussi rapide ou plus rapide que la gestion manuelle de la mémoire, et dans de nombreux cas, elle l'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 aux erreurs.

Comme l'a dit Donald Knuth, "l'optimisation prématurée est la racine de tout mal". Si vous savez vraiment avec certitude que votre application consistera principalement en arithmétique très critique en termes de performances, et qu'elle constituera le goulot d'étranglement, et qu'elle sera certainement plus rapide en C ++, et vous êtes sûr que C ++ n'entrera pas en conflit avec les autres exigences, optez pour C ++. Dans tous les autres cas, concentrez-vous d'abord sur l'implémentation correcte de votre application dans la langue qui vous convient le mieux, puis trouvez les goulots d'étranglement des performances si elle s'exécute trop lentement, puis réfléchissez à la façon d'optimiser le code. Dans le pire des cas, vous devrez peut-être appeler le code C via une interface de fonction étrangère, vous aurez donc toujours la possibilité 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 de corriger un programme optimisé.

Il est impossible de donner des pourcentages réels d'avantages de vitesse, cela dépend en grande partie de votre code. Dans de nombreux cas, l'implémentation du langage de programmation n'est même pas le goulot d'étranglement. Prenez les références sur http://benchmarksgame.alioth.debian.org/ avec beaucoup de scepticisme, car elles testent largement le code arithmétique, qui n'est probablement pas du tout similaire à votre code.

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

C'est cinq oranges plus rapides. Ou plutôt: il ne peut y avoir de réponse globale (correcte). C ++ est un langage compilé statiquement (mais il y a aussi une optimisation guidée par profil), C # s'exécute aidé par un compilateur JIT. Il y a tellement de différences qu'il est impossible de répondre à des questions comme «à quelle vitesse», même en donnant des ordres de grandeur.

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

Il y a en fait beaucoup de raisons pour lesquelles le code JITted fonctionnera plus lentement qu'un programme C ++ correctement optimisé (ou tout autre langage sans surcharge d'exécution), notamment:

• les cycles de calcul consacrés au code JITting lors de l'exécution ne sont par définition pas disponibles pour une utilisation dans l'exécution du programme.

• tous les chemins chauds dans le JITter seront en concurrence avec votre code pour le cache d'instructions et de données dans le CPU. Nous savons que le cache domine en termes de performances et que les langages natifs comme C ++ n'ont pas ce type de conflit, par définition.

• le budget-temps d'un optimiseur au moment de l'exécution est nécessairement beaucoup plus contraint que celui d'un optimiseur au moment de la compilation (comme l'a souligné un autre intervenant)

Bottom line: En fin de compte, vous voulez presque certainement en mesure de créer une implémentation plus rapide en C ++ que vous ne le pourriez en C # .

Maintenant, cela dit, combien plus rapide n'est vraiment pas quantifiable, car il y a trop de variables: la tâche, le domaine du problème, le matériel, la qualité des implémentations et de nombreux autres facteurs. Vous devrez exécuter des tests sur votre scénario pour déterminer la différence de performances, puis décider s'il vaut la peine de l'effort et de la complexité supplémentaires.

C'est un sujet très long et complexe, mais je pense qu'il vaut la peine de mentionner pour être complet que l'optimiseur d'exécution de C # est excellent, et est capable d'effectuer certaines optimisations dynamiques lors de l'exécution qui ne sont tout simplement pas disponibles pour C ++ avec son temps de compilation ( optimiseur statique). Même avec cela, l'avantage est toujours profondément ancré dans la cour de l'application native, mais l'optimiseur dynamique est la raison du " presque qualificatif certainement" donné ci-dessus.

-

En termes de performances relatives, j'ai également été troublé par les chiffres et les discussions que j'ai vus dans certaines autres réponses, j'ai donc pensé que je ferais sonner la voix et, en même temps, apporterais un certain soutien aux déclarations que j'ai faites ci-dessus.

Une grande partie du problème avec ces benchmarks est que vous ne pouvez pas écrire de code C ++ comme si vous écriviez C # et espérez obtenir des résultats représentatifs (par exemple, effectuer des milliers d'allocations de mémoire en C ++ va vous donner des chiffres terribles.)

Au lieu de cela, j'ai écrit un code C ++ légèrement plus idiomatique et comparé au code C # @Wiory fourni. Les deux changements majeurs que j'ai apportés au code C ++ étaient:

1) utilisé vector :: reserve ()

2) aplati le tableau 2d à 1d pour obtenir une 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);
}

Durée d'exécution (Release): Init: 124ms, Fill: 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);
}

Durée d'exécution (Release): Init: 398µs (oui, c'est microsecondes), Fill: 152ms

Temps d'exécution total: C #: 289 ms, C ++ 152 ms (environ 90% plus rapide)

Observations

• La modification de l'implémentation C # en la même implémentation de tableau 1d a donné Init: 40ms, Fill: 171ms, Total: 211ms ( C ++ était toujours presque 40% plus rapide ).

• Il est beaucoup plus difficile de concevoir et d'écrire du code "rapide" en C ++ que d'écrire du code "normal" 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 non réservés. Et il y a beaucoup de pièges comme celui-ci.

• Les performances de C # sont plutôt étonnantes quand on considère tout ce qui se passe au moment de l'exécution. Et cette performance est relativement facile d'accès.

• Plus de données anecdotiques comparant les performances de C ++ et C #: https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=gpp&lang2=csharpcore

L'essentiel est que C ++ vous donne beaucoup plus de contrôle sur les performances. Voulez-vous utiliser un pointeur? Une référence? Empiler la mémoire? Tas? Polymorphisme dynamique ou éliminer la surcharge d'exécution d'une table virtuelle avec polymorphisme statique (via des modèles / CRTP)? En C ++, vous devez ... euh, accéder à faire tous ces choix (et plus) vous, idéalement afin que vos meilleures adresses de solution du problème que vous vous attaquez.

Demandez-vous si vous voulez ou avez réellement besoin de ce contrôle, car même pour l'exemple trivial ci-dessus, vous pouvez voir que bien qu'il y ait une amélioration significative des performances, il nécessite un investissement plus profond pour y accéder.

D'après mon expérience (et j'ai beaucoup travaillé avec les deux langages), le principal problème avec C # par rapport à C ++ est la consommation élevée de mémoire, et je n'ai pas trouvé de bon moyen de le contrôler. C'était la consommation de mémoire qui ralentirait finalement le logiciel .NET.

Un autre facteur est que le compilateur JIT ne peut pas se permettre trop de temps pour effectuer des optimisations avancées, car il s'exécute au moment de l'exécution, et l'utilisateur final le remarquerait s'il prend trop de temps. D'un autre côté, un compilateur C ++ dispose de tout le temps nécessaire pour effectuer des optimisations au moment de la compilation. Ce facteur est beaucoup moins important que la consommation de mémoire, à mon humble avis.

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

En règle générale, l'encapsulation et la prise de décision différée sont une bonne chose car elles rendent le code plus dynamique, plus facile à adapter aux exigences changeantes 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 de «généralisation». Malheureusement, ce type particulier de généralisation a un coût au moment de l'exécution.

Habituellement, ce coût n'est pas substantiel, mais il existe des applications où les frais généraux d'appels de méthode virtuelle et de création d'objet peuvent faire la différence (d'autant plus que les méthodes virtuelles empêchent d'autres optimisations telles que l'inlining d'appel de méthode). C'est là que C ++ a un énorme avantage car vous pouvez utiliser des modèles pour réaliser un type de généralisation différent qui n'a aucun impact sur l'exécution mais n'est pas nécessairement moins polymorphe que la POO. En fait, tous les mécanismes qui constituent la POO peuvent être modélisés en utilisant uniquement des techniques de modèle et une résolution au moment de la compilation.

Dans de tels cas (et certes, ils sont souvent limités à des domaines à problèmes spéciaux), C ++ gagne contre C # et des langages comparables.

C ++ (ou C d'ailleurs) vous donne un contrôle précis sur vos structures de données. Si vous voulez bit-twiddle vous avez cette option. Les grandes applications Java ou .NET gérées (OWB, Visual Studio 2005 ) qui utilisent les structures de données internes des bibliothèques Java / .NET transportent le bagage avec elles. J'ai vu des sessions de conception OWB utilisant plus de 400 Mo de RAM et BIDS pour la conception de cubes ou ETL entrer dans les 100 de Mo également.

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 suffisamment bien optimisé pour qu'il n'y ait pas de différence pratique.

OMI sur les grandes applications, la différence n'est pas tant le JIT que les structures de données que le code lui-même utilise. Lorsqu'une application est gourmande en mémoire, vous obtiendrez une utilisation du cache moins efficace. Les échecs de cache sur les processeurs modernes sont assez chers. Là où C ou C ++ gagne vraiment, c'est là que vous pouvez optimiser votre utilisation des structures de données pour bien jouer avec le cache du processeur.

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

Nous avons un référentiel simple que nous utilisons pour voir à quelle vitesse une bibliothèque graphique est, et qui consiste simplement à dessiner des lignes aléatoires dans une fenêtre. C ++ / GDI est toujours accrocheur avec 10000 lignes tandis que C # / Graphics a du mal à en faire 1000 en temps réel.

Le garbage collection 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?

Ce n'est pas déterministe.

Nous avons dû déterminer si C # était comparable à C ++ en termes de performances et j'ai écrit quelques programmes de test pour cela (en utilisant Visual Studio 2005 pour les deux langages). Il s'est avéré que sans garbage collection et en ne considérant que le langage (pas le framework), C # a fondamentalement les mêmes performances 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 les tailles de données sont augmentées au-delà des limites de la ligne de cache. Cependant, tout cela a finalement dû être payé et il y a un coût énorme sous la forme de résultats de performances non déterministes pour C # en raison de la collecte des ordures.

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

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

C / C ++ peut être beaucoup plus performant dans les programmes où il y a soit de grands tableaux, soit des boucles / itérations lourdes 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 ++, car les opérations de tableau lourd sous-tendent presque toutes les opérations graphiques. .NET est notoirement lent dans les opérations d'indexation de tableaux en raison de toutes les vérifications de sécurité, et cela est particulièrement vrai pour les tableaux multidimensionnels (et, oui, les tableaux C # rectangulaires sont encore plus lents que les tableaux C # dentelés).

Les bonus de C / C ++ sont plus prononcés si vous vous en tenez directement aux pointeurs et évitez Boost std::vectoret autres conteneurs de haut niveau, ainsi que inlinetoutes les petites fonctions possibles. Utilisez des tableaux à l'ancienne autant que 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, il vous suffit de vous rappeler de le coupler new T[]avec un correspondantdelete[] instruction (ou d'utiliserstd::unique_ptr) - le prix de la vitesse supplémentaire est que vous devez coder plus soigneusement. Mais en échange, vous pouvez vous débarrasser de la surcharge de la mémoire gérée / du garbage collector, qui peut facilement représenter 20% ou plus du temps d'exécution des programmes fortement orientés objet en Java et .NET, ainsi que ceux massivement gérés les coûts d'indexation des matrices de mémoire. Les applications C ++ peuvent également bénéficier de certains commutateurs de compilateur astucieux dans certains cas spécifiques.

Je suis un programmeur expert en C, C ++, Java et C #. J'ai récemment eu l'occasion rare d'implémenter exactement le même programme algorithmique dans les 3 dernières langues. Le programme a eu beaucoup d'opérations mathématiques et de tableaux multidimensionnels. J'ai fortement optimisé cela dans les 3 langues. Les résultats étaient typiques de ce que je vois normalement dans des comparaisons moins rigoureuses: Java était environ 1,3 fois plus rapide que C # (la plupart des machines virtuelles Java sont plus optimisées que le CLR), et la version du pointeur brut C ++ est arrivée environ 2,1 fois plus rapide que C #. Notez que le programme C # n'utilisait que du code sécurisé - je pense que vous pourriez aussi bien le coder en C ++ avant d'utiliser leunsafe mot clé.

De peur que quelqu'un pense que j'ai quelque chose contre C #, je terminerai en disant que C # est probablement mon langage préféré. 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 # présente de nombreux petits avantages subtils par rapport à Java (oui, je sais que Microsoft a eu la chance de corriger de nombreuses lacunes de Java en entrant tardivement dans le jeu et en copiant sans doute Java). Un toast à la Calendarclasse de Java ? Si Microsoft consacre un effort réel à optimiser le CLR et le .NET JITter, C # pourrait sérieusement prendre le relais. Je suis honnêtement surpris qu'ils ne l'aient pas déjà fait - ils ont fait tellement de choses correctement dans le langage C #, pourquoi ne pas le suivre avec des optimisations de compilateur lourdes? Peut-être que si nous mendions tous.

> 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é ne fera que se répéter lorsque vous tenterez 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 des preuves .

Lorsque quelqu'un prétend "qu'il existe des domaines dans lesquels C # s'avère plus rapide que C ++", demandez-lui pourquoi il dit que , demandez-lui de vous montrer des mesures, demandez-lui de vous montrer des programmes. Parfois, ils auront 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, les informations et les opinions seront mélangées dans ce que les gens prétendent, et vous devrez essayer de déterminer lequel est lequel. Par exemple, à partir des réponses de ce forum:

• "Prenez les références sur http://shootout.alioth.debian.org/ avec beaucoup de scepticisme, car elles testent largement le code arithmétique, qui n'est probablement pas du tout similaire à votre code."

  Demandez-vous si vous comprenez vraiment ce que «ces codes arithmétiques largement testés» signifient, puis demandez-vous si l'auteur vous a réellement montré que sa prétention est vraie.

• "C'est un test plutôt inutile, car cela dépend vraiment de la façon dont les programmes individuels ont été optimisés. J'ai réussi à accélérer certains d'entre eux de 4 à 6 fois ou plus, ce qui montre clairement que la comparaison entre les programmes non optimisés est plutôt idiot."

  Demandez-vous si l'auteur vous a réellement montré qu'il a réussi à "accélérer certains d'entre eux de 4 à 6 fois ou plus" - c'est une affirmation facile à faire!

Pour les problèmes «embarrassants parallèles», lorsque j'utilise Intel TBB et OpenMP sur C ++, j'ai observé une augmentation de performances d'environ 10 fois par rapport à des problèmes similaires (mathématiques pures) effectués avec C # et TPL. SIMD est un domaine où C # ne peut pas rivaliser, mais j'ai également eu l'impression que TPL a une surcharge importante.

Cela dit, j'utilise uniquement C ++ pour les tâches critiques pour les performances où je sais que je serai en mesure de multithread et d'obtenir des résultats rapidement. Pour tout le reste, C # (et parfois F #) est très bien.

C'est une question extrêmement vague sans véritables réponses définitives.

Par exemple; Je préfère jouer à des jeux 3D créés en C ++ qu'en C #, car les performances sont certainement bien meilleures. (Et je connais XNA, etc., mais cela ne se rapproche pas du vrai).

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

Les langages .NET peuvent être aussi rapides que le code C ++, voire plus rapides, mais le code C ++ aura un débit plus constant car le runtime .NET doit faire une pause pour GC , même s'il est très intelligent sur ses pauses.

Donc, si vous avez du code qui doit constamment s'exécuter rapidement sans aucune pause, .NET introduira une latence à un moment donné , même si vous êtes très prudent avec le GC d'exécution.

En théorie, pour une application de type serveur de longue durée, un langage compilé JIT peut devenir beaucoup plus rapide qu'un équivalent compilé en mode natif. Étant donné que le langage compilé JIT est généralement d'abord compilé dans un langage intermédiaire de bas niveau, vous pouvez de toute façon effectuer de nombreuses optimisations de haut niveau au moment de la compilation. Le gros avantage est que le JIT peut continuer à recompiler des sections de code à la volée car il obtient de plus en plus de données sur la façon dont l'application est utilisée. Il peut organiser les chemins de code les plus courants pour permettre à la prédiction de branchement de réussir aussi souvent que possible. Il peut réorganiser des blocs de code séparés qui sont souvent appelés ensemble pour les garder tous les deux dans le cache. Il peut consacrer plus d'efforts à l'optimisation des boucles internes.

Je doute que cela soit fait par .NET ou l'un des JRE, mais cela faisait l'objet de recherches lorsque j'étais à l'université, il n'est donc pas déraisonnable de penser que ce genre de choses pourrait se retrouver dans le monde réel à un moment donné prochainement. .

Les applications qui nécessitent un accès intensif à la mémoire, par exemple. la manipulation d'images est généralement mieux écrite en environnement non managé (C ++) que managée (C #). Les boucles internes optimisées avec l'arithmétique des pointeurs sont beaucoup plus faciles à contrôler en C ++. En C #, vous devrez peut-être recourir à du code non sécurisé pour obtenir même les mêmes performances.

J'ai testé vectoren équivalent C ++ et C # - Listet des tableaux 2d simples.

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

J'utilise Intel Core2Duo [email protected], C # - .NET 4.0.

Je sais que l'implémentation vectorielle est différente de la liste C #, 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 la mémoire (disons pour chaque utilisation de new), mais je voulais garder le code simple.

Test vectoriel C ++ :

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

Test de liste C #:

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

}

Heure: (Release / Debug)

C ++

• Init de tableau 600/606 ms,
• Remplissage du tableau 200/270 ms,
• 1sec / 13sec vecteur init & fill.

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

C #:

• Init de tableau 20/20 ms,
• Remplissage de matrice 403/440 ms,
• 710/742 ms liste init & fill.

En fait ça dépend. Si le code d'octet est traduit en code machine (et pas seulement JIT) (je veux dire si vous exécutez le programme) et si votre programme utilise de nombreuses allocations / désallocations, cela pourrait être plus rapide car l' algorithme GC n'a besoin que d'un passage (théoriquement) dans toute la mémoire une fois, mais les appels normaux malloc / realloc / free C / C ++ entraînent une surcharge pour chaque appel (surcharge d'appel, surcharge de structure de données, échecs de cache;)).

Il est donc théoriquement possible (également pour d'autres langages GC).

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

Un autre gros avantage est que le SQL, comme l ' "extension" LINQ , offre au compilateur la possibilité d'optimiser les appels aux bases de données (en d'autres termes, le compilateur pourrait compiler le LINQ entier dans un binaire "blob" où les fonctions appelées sont en ligne ou pour votre utilisation optimisée, mais je spécule ici).

Je suppose qu'il y a des applications écrites en C # qui s'exécutent rapidement, ainsi que d'autres applications écrites en C ++ qui s'exécutent rapidement (enfin C ++ juste plus ancien ... et prennent UNIX aussi ...)
- la question est en effet - quelle est cette chose, les utilisateurs et les développeurs se plaignent de ...
Eh bien, à mon humble avis, dans le cas de C #, nous avons une interface utilisateur très confortable, une très belle hiérarchie de bibliothèques et tout le système d'interface de CLI. Dans le cas de C ++, nous avons des modèles, ATL, COM, MFC et tout le code déjà écrit et en cours d'exécution comme OpenGL, DirectX et ainsi de suite ... en une seconde - bang! c'est coincé).
Pour écrire du code en C # très simple et rapide (sans oublier cela augmente également les risques d'erreurs. En cas de C ++, les développeurs se plaignent de fuites de mémoire, - signifie des écrasements, des appels entre DLL, ainsi que de "l'enfer des DLL" - problème avec support et remplacement des bibliothèques par des 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.

Je dirais les choses ainsi: les programmeurs qui écrivent du code plus rapidement sont ceux qui sont les mieux informés de ce qui fait que les machines actuelles vont vite, et accessoirement ce sont aussi ceux qui utilisent un outil approprié qui permet un bas niveau précis et déterministe techniques d'optimisation. Pour ces raisons, ces personnes sont celles qui utilisent C / C ++ plutôt que C #. J'irais jusqu'à affirmer cela comme un fait.

Si je ne me trompe pas, les modèles C # sont déterminés lors de 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 au moment de la 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 à vous assurer que vous ne perdez pas de mémoire ou ne provoquez aucune exception de pointeur nul.

Verdict:

• C #: développement plus rapide, exécution plus lente

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

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

Je n'ai en aucun cas fait de comparaisons exhaustives en termes de complexité algorithmique entre les langues. J'utilise également les paramètres par défaut dans chacune des langues. Dans VB.NET, j'utilise des paramètres pour exiger la déclaration de variables, etc. Voici le code que j'utilise pour le C ++ managé: (Comme vous pouvez le voir, ce code est assez simple). J'exécute la même chose dans les autres langues de 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;
}

Il existe quelques différences majeures entre C # et C ++ sur l'aspect performances:

• C # est basé sur GC / tas. L'allocation et le GC lui-même sont des frais généraux comme la non localité de l'accès à la mémoire
• Les optimiseurs C ++ sont devenus très bons au fil des ans. Les compilateurs JIT ne peuvent pas atteindre le même niveau car ils ont seulement un temps de compilation limité et ne voient pas la portée globale

Outre que la compétence du programmeur joue également un rôle. J'ai vu un mauvais code C ++ où les classes étaient passées par valeur comme argument partout. Vous pouvez réellement aggraver les performances en C ++ si vous ne savez pas ce que vous faites.

> Après tout, les réponses doivent être quelque part, non? :)

Umm, non.

Comme plusieurs réponses l'ont noté, la question est sous-spécifiée de manière à inviter des questions à répondre, pas des réponses. Pour prendre une seule façon:

• la question confond le langage avec l'implémentation du langage - ce programme C est à la fois 2194 fois plus lent et 1,17 fois plus rapide que ce programme C # - nous devrions vous demander: quelles implémentations du langage?

Et puis quels programmes? Quelle machine? Quel OS? Quel ensemble de données?

Inspiré par cela, j'ai fait un test rapide avec 60% des instructions communes nécessaires 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();
}

Le tableau de chaînes et l'arraylist sont utilisés à dessein 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 Ko.

Et voici le résultat -

• Le code C ++ a fonctionné en 9 secondes.
• Code C #: 4 secondes !!!

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

OK, voici ce que j'ai obtenu sous Windows - Visual Studio 2003 :

• Le code C # a fonctionné en 9 secondes.
• Code C ++ - horrible 370 secondes !!!