Ce qui est plus efficace? En utilisant pow pour carré ou simplement le multiplier avec lui-même?

C'est le mauvais genre de question. La bonne question serait: "lequel est le plus facile à comprendre pour les lecteurs humains de mon code?"

Si la vitesse compte (plus tard), ne demandez pas, mais mesurez. (Et avant cela, mesurez si l'optimisation de cela fera réellement une différence notable.) Jusque-là, écrivez le code afin qu'il soit plus facile à lire.

Modifier
Juste pour que cela soit clair (bien que cela aurait déjà dû l'être): les accélérations révolutionnaires viennent généralement des choses comme les l'utilisation de meilleurs algorithmes, l'amélioration de la localité de données, la réduction de l'utilisation de la mémoire dynamique, pré-calcul des résultats, etc. Ils ont rarement jamais venu à partir de micro-optimisation de la fonction unique d'appels, et lorsqu'ils le font, ils le font dans très peu de places, ce qui ne pourrait être trouvé par attention (et de temps) profilage, le plus souvent jamais ils ne peuvent être accélérés en faisant des choses très non intuitives (comme l'insertion d'instructions noop), et ce qui est une optimisation pour une plate-forme est parfois une pessimisation pour une autre (c'est pourquoi vous devez mesurer, au lieu de demander, parce que nous ne connaissons pas complètement/avons votre environnement).

Permettez-moi de souligner à nouveau ceci: même dans les quelques applications où de telles choses comptent, elles n'ont pas d'importance dans la plupart des endroits où elles sont utilisées, et il est Très peu probable que vous trouviez les endroits où ils comptent en regardant le code. Vous avez vraiment besoin de identifier les points chauds de la première, parce que sinon, l'optimisation de code est juste une perte de temps.

, Même si une seule opération (comme le calcul du carré de la valeur) prend 10% de l'exécution de l'application en temps (qui IME qui est assez rare), et même si l'optimisation de ce dernier enregistre 50% du temps nécessaire pour cette opération (qui IME est même beaucoup, beaucoup plus rare), vous avez encore fait la demande de prendre seulement 5% de temps en moins.
Vos utilisateurs auront besoin d'un chronomètre pour même le remarquer. (Je suppose que dans la plupart des cas, quelque chose sous 20% speedup passe inaperçu pour la plupart des utilisateurs. Et que est quatre de ces endroits que vous devez trouver.)

x*x ou x*x*x sera plus rapide que pow depuis pow doit traiter le cas général, tandis que x*x est spécifique. En outre, vous pouvez elide l'appel de fonction et telchlike.

Cependant, si vous vous trouvez micro-optimisation comme ça, vous devez obtenir un profileur et faire un profilage sérieux. La probabilité écrasante est que vous ne remarquerez jamais aucune différence entre les deux.

Je m'interrogeais également sur le problème des performances, et j'espérais que cela serait optimisé par le compilateur, basé sur la réponse de @EmileCormier. Cependant, j'étais inquiet que le code de test qu'il a montré permettrait toujours au compilateur d'optimiser l'appel std::pow (), puisque les mêmes valeurs étaient utilisées dans l'appel à chaque fois, ce qui permettrait au compilateur de stocker les résultats et de les réutiliser dans la boucle-cela expliquerait les temps d'exécution presque identiques pour tous les cas. J'ai donc eu un coup d'oeil trop.

Voici le code que j'ai utilisé (test_pow.rpc):

#include <iostream>                                                                                                                                                                                                                       
#include <cmath>
#include <chrono>

class Timer {
  public:
    explicit Timer () : from (std::chrono::high_resolution_clock::now()) { }

    void start () {
      from = std::chrono::high_resolution_clock::now();
    }

    double elapsed() const {
      return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - from).count() * 1.0e-6;
    }

  private:
    std::chrono::high_resolution_clock::time_point from;
};

int main (int argc, char* argv[])
{
  double total;
  Timer timer;



  total = 0.0;
  timer.start();
  for (double i = 0.0; i < 1.0; i += 1e-8)
    total += std::pow (i,2);
  std::cout << "std::pow(i,2): " << timer.elapsed() << "s (result = " << total << ")\n";

  total = 0.0;
  timer.start();
  for (double i = 0.0; i < 1.0; i += 1e-8)
    total += i*i;
  std::cout << "i*i: " << timer.elapsed() << "s (result = " << total << ")\n";

  std::cout << "\n";

  total = 0.0;
  timer.start();
  for (double i = 0.0; i < 1.0; i += 1e-8)
    total += std::pow (i,3);
  std::cout << "std::pow(i,3): " << timer.elapsed() << "s (result = " << total << ")\n";

  total = 0.0;
  timer.start();
  for (double i = 0.0; i < 1.0; i += 1e-8)
    total += i*i*i;
  std::cout << "i*i*i: " << timer.elapsed() << "s (result = " << total << ")\n";


  return 0;
}

Cela a été compilé en utilisant:

g++ -std=c++11 [-O2] test_pow.cpp -o test_pow

Fondamentalement, la différence est l'argument de std:: pow () est le compteur de boucle. Comme je le craignais, la différence de performance est prononcée. Sans l'indicateur-O2, les résultats sur mon système (Arch Linux 64 bits, g++ 4.9.1, Intel i7-4930)étaient:

std::pow(i,2): 0.001105s (result = 3.33333e+07)
i*i: 0.000352s (result = 3.33333e+07)

std::pow(i,3): 0.006034s (result = 2.5e+07)
i*i*i: 0.000328s (result = 2.5e+07)

Avec l'optimisation, les résultats étaient tout aussi frappants:

std::pow(i,2): 0.000155s (result = 3.33333e+07)
i*i: 0.000106s (result = 3.33333e+07)

std::pow(i,3): 0.006066s (result = 2.5e+07)
i*i*i: 9.7e-05s (result = 2.5e+07)

Il semble donc que le compilateur essaie au moins pour optimiser le std::pow(x,2), mais pas le std::pow(x,3) cas (il faut ~40 fois plus longtemps que les std::pow(x,2)). Dans tous les cas, l'expansion manuelle a mieux fonctionné - mais en particulier pour le boîtier power 3 (60 fois plus rapide). Cela vaut vraiment la peine de garder à l'esprit si vous exécutez std::pow() avec des puissances entières supérieures à 2 dans une boucle serrée...

Le moyen le plus efficace est de considérer la croissance exponentielle des multiplications. Vérifiez ce code pour p^q:

template <typename T>
T expt(T p, unsigned q){
    T r =1;
    while (q != 0) {
        if (q % 2 == 1) {    // if q is odd
            r *= p;
            q--;
        }
        p *= p;
        q /= 2;
    }
    return r;
}

Si l'exposant est constant et petit, développez-le, en minimisant le nombre de multiplications. (Par exemple, x^4 n'est pas optimale x*x*x*x, mais y*y où y=x*x. Et x^5 est y*y*x où y=x*x. Et ainsi de suite.) Pour les exposants entiers constants, il suffit d'écrire la forme optimisée déjà; avec les petits exposants, il s'agit d'une optimisation standard qui doit être effectuée, que le code ait été profilé ou non. Le formulaire optimisé sera plus rapide dans un si grand pourcentage de cas qu'il est fondamentalement toujours la peine de faire.

(si vous utilisez Visual C++, std::pow(float,int) effectue l'optimisation à laquelle je fais allusion, la séquence d'opérations étant liée au modèle de bits de l'exposant. Je ne garantis pas que le compilateur déroulera la boucle pour vous, donc ça vaut toujours la peine de le faire à la main.)

[edit] BTW pow a une tendance (non)surprenante à apparaître sur les résultats du profileur. Si vous n'avez pas absolument besoin (c'est à dire, l'exposant est grand ou pas une constante), et vous êtes du tout préoccupé par les performances, il est préférable d'écrire le code optimal et d'attendre que le profileur vous dise que c'est (étonnamment) perdre du temps avant de penser plus loin. (L'alternative est d'appeler pow et d'avoir le profileur vous dire que c'est (sans surprise) perdre du temps-vous découpez cette étape en le faisant intelligemment.)