Réponse acceptée !
Pour étudier la puissance C vs C++, je me propose d'étudier un peu la fonction mathématique "puissance" justement.
Les macros du C permettent souvent de faire le même code que les templates du C++. Mais pas toujours, comme ici.
C'est un algo parfois cité comme exemple où le C++ et ses templates, permettant la meta programmation, est censé permettre d'
obtenir ni plus ni moins qu'un code plus optimisé. "Optimisé" au sens performance à l'exécution meilleurs que celle du C à ce que je comprend.
Comment ? On va en fait utiliser les templates pour que le code machine généré soit exactement le bon code.
On évite boucle, tests, et théoriquement même la récursivité. On sait que :
x^Y = x * x ^ (Y - 1)
x^0 = 1
Code testé sous gcc :
#include <iostream>
#include <stdlib.h>
#include <windows.h>
#define X 5
#define Y 5
using namespace std;
template <int N> inline double Puissance(double x)
{
return x * Puissance<N - 1>(x);
}
template <> inline double Puissance<0>(double x)
{
return 1.0;
}
double inline PuissanceC(double x, int N)
{
int i;
double res;
res = 1;
for (i = N; i > 0; i--)
res *= x;
return res;
}
double inline PuissanceC2(double x, int N)
{
if (N == 0) return 1.0;
return x * PuissanceC2(x, N - 1);
}
int main()
{
LARGE_INTEGER init;
LARGE_INTEGER end;
double res;
QueryPerformanceCounter(&init);
res = Puissance<Y>(X);
QueryPerformanceCounter(&end);
cout << res << " " << end.LowPart - init.LowPart << endl;
QueryPerformanceCounter(&init);
res = PuissanceC(X, Y);
QueryPerformanceCounter(&end);
cout << res << " " << end.LowPart - init.LowPart << endl;
QueryPerformanceCounter(&init);
res = PuissanceC2(X, Y);
QueryPerformanceCounter(&end);
cout << res << " " << end.LowPart - init.LowPart << endl;
system("pause");
}
En théorie, le code C++ est plus rapide, et devrait être composé d'une série de Y multiplications par X. Pas de test, pas d'incrémentations... Un code "customisé" en somme.
En pratique, bif bof. Plutôt bof même.
Faut dire que le compilo soit sacrément intelligent pour optimiser correctement notre template. Les résultats dépendent fortement de X et Y, et probablement des options de compilations.
Bon admettons que le compilo soit très intelligent. Faut se dire que ça va arriver un jour.
Conclusion : La voici, la preuve finale, ultime, suprême, incontestable, que comme le Java qui peut être plus rapide que le C (Je l'ai jamais vu celle là !) le C++ peut générer du code plus rapide que le C !
Brûlez le C !
Faîtes du C++ !
Nan partez pas encore, c'était une blague !
En fait on peut optimiser le code :
res = 3125;
Bah vi, tout est connu à la compilation !
Mais supposons que cela ne soit pas le cas...
Y est forcément connu pour que le compilo puisse générer le code du template.
Donc même pour le code C, un compilo intelligent pourrait inliner PuissanceC2 et dérouler la boucle.
Sachant qu'on peut l'inciter un peu plus à le faire avec une macro :
#define PuissanceC3(result, x, N) { \
int i; \
\
result = 1; \
for (i = N; i > 0; i--) \
result *= x; \
}
Mais cela n'est pas si intéressant que ça à l'usage.
Vrai conclusion : Alors oui, je te plussois cosmobob : le C++ est plus puissant que le C. Tout le code ci-desssus est en C++ après tout. Mais un cas où les fonctionnalités que le C++ a en plus du C apporte quelque chose de vraiment positif je cherche encore.
Faut pas oublier les inconvénients des templates :
Codes généré plus gros, autant de fois que l'on instancie le template (Sous certaines condition, généré une seule fois pour un Y).
Temps de compilation plus élevé. C'est toujours "amusant" à constater sur les projets mixtes C/C++.
Pas des plus portables : Le code ci-dessus ne fonctionne pas sous VC6. Non testé sous un autre VC.
Plutôt technique à coder. Vite fait de faire une bourde et code pas des plus lisible.
Le débogage (Pas à pas...) est plus complexe, vu que le lien entre le source et le code généré est plus floux.