Quelle est la fonction C ++ pour élever un nombre à une puissance?

Comment élever un nombre à une puissance?

2^1

2^2

2^3

etc...

pow () dans la bibliothèque cmath. Plus d'infos ici . N'oubliez pas de mettre #include<cmath>en haut du fichier.

std::powdans l'en- <cmath>tête a ces surcharges:

pow(float, float);
pow(float, int);
pow(double, double); // taken over from C
pow(double, int);
pow(long double, long double);
pow(long double, int);

Maintenant tu ne peux pas juste faire

pow(2, N)

N étant un entier, car il ne sait pas quel float, doubleou la long doubleversion qu'il devrait prendre, et vous obtiendrez une erreur d'ambiguïté. Les trois nécessiteraient une conversion de int en virgule flottante, et les trois sont également coûteux!

Par conséquent, assurez-vous d'avoir tapé le premier argument pour qu'il corresponde parfaitement à l'un de ces trois. J'utilise habituellementdouble

pow(2.0, N)

Encore une merde d'avocat de ma part. Je suis souvent moi-même tombé dans cet écueil, alors je vais vous en avertir.

En C ++, l'opérateur "^" est un OU au niveau du bit. Cela ne fonctionne pas pour s'élever à une puissance. Le x << n est un décalage vers la gauche du nombre binaire qui équivaut à multiplier x par 2 n nombre de fois et qui ne peut être utilisé que pour élever 2 à une puissance. La fonction POW est une fonction mathématique qui fonctionnera de manière générique.

Vous devriez pouvoir utiliser les méthodes C normales en mathématiques.

#include <cmath>

pow(2,3)

si vous êtes sur un système de type Unix, man cmath

C'est ce que vous demandez?

Sujal

Utilisez la fonction pow (x, y): voir ici

Incluez simplement math.h et vous êtes prêt.

Bien que ce pow( base, exp )soit une excellente suggestion, sachez que cela fonctionne généralement en virgule flottante.

C'est peut-être ce que vous voulez ou non: sur certains systèmes, une simple boucle de multiplication sur un accumulateur sera plus rapide pour les types entiers.

Et pour le carré en particulier, vous pouvez tout aussi bien multiplier les nombres ensemble vous-même, en virgule flottante ou en entier; ce n'est pas vraiment une diminution de la lisibilité (IMHO) et vous évitez la surcharge de performance d'un appel de fonction.

Je n'ai pas assez de réputation pour commenter, mais si vous aimez travailler avec QT, ils ont leur propre version.

    #include <QtCore/qmath.h>
    qPow(x, y); // returns x raised to the y power.

Ou si vous n'utilisez pas QT, cmath a fondamentalement la même chose.

    #include <cmath>
    double x = 5, y = 7; //As an example, 5 ^ 7 = 78125
    pow(x, y); //Should return this: 78125

#include <iostream>
#include <conio.h>

using namespace std;

double raiseToPow(double ,int) //raiseToPow variable of type double which takes arguments (double, int)

void main()
{
    double x; //initializing the variable x and i 
    int i;
    cout<<"please enter the number"; 
    cin>>x;
    cout<<"plese enter the integer power that you want this number raised to";
    cin>>i;
    cout<<x<<"raise to power"<<i<<"is equal to"<<raiseToPow(x,i);
}

// définition de la fonction riseToPower

double raiseToPow(double x, int power)
{
    double result;
    int i;
    result =1.0;
    for (i=1, i<=power;i++)
    {
        result = result*x;
    }
    return(result);
}

si vous voulez traiter uniquement base_2, je vous recommande d'utiliser l'opérateur de décalage gauche << au lieu de la bibliothèque mathématique .

exemple de code:

int exp = 16;
for(int base_2 = 1; base_2 < (1 << exp); (base_2 <<= 1)){
std::cout << base_2 << std::endl;
}

exemple de sortie:

1   2   4   8   16  32  64  128  256  512  1024  2048  4096  8192  16384  32768

C'est pow ou powf dedans <math.h>

Il n'y a pas d'opérateur d'infixe spécial comme dans Visual Basic ou Python

De nombreuses réponses ont suggéré pow()ou des alternatives similaires ou leurs propres implémentations. Cependant, étant donné les exemples ( 2^1, 2^2et 2^3) de votre question, je suppose que vous devez seulement augmenter 2à une puissance entière. Si tel est le cas, je vous suggère d'utiliser 1 << npour 2^n.

pow(2.0,1.0)
pow(2.0,2.0)
pow(2.0,3.0)

Le titre de votre question d'origine est trompeur. Pour juste carré , utilisez 2*2.

Notez que l'utilisation de pow(x,y)est moins efficace que x*x*xy fois comme indiqué et répondu ici https://stackoverflow.com/a/2940800/319728 .

Donc, si vous optez pour une utilisation efficace x*x*x.

int power (int i, int ow) // works only for ow >= 1
{ // but does not require <cmath> library!=)
    if (ow > 1)
    {
         i = i * power (i, ow - 1);
    }
    return i;
}

cout << power(6,7); //you can enter variables here

J'utilise la bibliothèque cmathou math.hpour utiliser les pow()fonctions de la bibliothèque qui s'occupent des pouvoirs

#include<iostream>
#include<cmath>

int main()
{
    double number,power, result;
    cout<<"\nEnter the number to raise to power: ";
    cin>>number;
    cout<<"\nEnter the power to raise to: ";
    cin>>power;

    result = pow(number,power);

    cout<<"\n"<< number <<"^"<< power<<" = "<< result;

    return 0;
}

Ajoutez d'abord, #include <cmath>puis vous pouvez utiliser la powméthode dans votre code par exemple:

pow(3.5, 3);

Quel 3,5 est la base et 3 est exp

utilisez la fonction pow () dans la bibliothèque cmath, tgmath ou math.h.

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
int a,b;
cin >> a >> b;
cout << pow(a,b) << endl; // this calculates a^b

return 0;
}

notez que si vous donnez une entrée à power comme n'importe quel type de données autre que long double, la réponse sera promue à celle de double. c'est-à-dire qu'il prendra l'entrée et donnera la sortie comme double. pour les entrées doubles longues, le type de retour est long double. pour changer la réponse en int use, int c = (int) pow (a, b)

Mais gardez à l'esprit que pour certains nombres, cela peut entraîner un nombre inférieur à la bonne réponse. par exemple, vous devez calculer 5 ^ 2, puis la réponse peut être renvoyée sous la forme 24,99999999999 sur certains compilateurs. en changeant le type de données en int, la réponse sera 24 plutôt que 25 la bonne réponse. Alors fais ça

int c=(int)(pow(a,b)+0.5)

Maintenant, votre réponse sera correcte. également, pour les très grands nombres, les données sont perdues lors du changement de type de données double en long long int. par exemple tu écris

long long int c=(long long int)(pow(a,b)+0.5);

et donnez l'entrée a = 3 et b = 38 alors le résultat sera 1350851717672992000 tandis que la bonne réponse est 1350851717672992089, cela se produit parce que la fonction pow () retourne 1.35085e + 18 qui est promu int comme 1350851717672992000. Je suggère d'écrire un fonction d'alimentation personnalisée pour de tels scénarios, comme: -

long long int __pow (long long int a, long long int b)
{
long long int q=1;
for (long long int i=0;i<=b-1;i++)
{
q=q*a;
}

return q;
}

et puis l'appelant quand tu veux comme,

int main()
{
long long int a,b;
cin >> a >> b;

long long int c=__pow(a,b);
cout << c << endl;

return 0;
}

Pour les nombres supérieurs à la plage de long long int, utilisez la bibliothèque boost ou des chaînes.