Qual è la funzione C ++ per aumentare un numero in una potenza?

Come faccio ad aumentare un numero in una potenza?

2^1

2^2

2^3

eccetera...

pow () nella libreria cmath. Maggiori informazioni qui . Non dimenticare di mettere #include<cmath>in cima al file.

std::pownella <cmath>intestazione ha queste sovraccarichi:

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

Ora non puoi semplicemente farlo

pow(2, N)

con N è un int, perché non sa quale di float, doubleo long doublela versione che dovrebbe assumere, e si otterrebbe un errore di ambiguità. Tutti e tre avrebbero bisogno di una conversione da int a virgola mobile e tutti e tre sono ugualmente costosi!

Pertanto, assicurati di aver digitato il primo argomento in modo che corrisponda perfettamente a uno di questi tre. Di solito usodouble

pow(2.0, N)

Un po 'di avvocato di nuovo da parte mia. Mi sono spesso imbattuto in questa trappola, quindi ti avvertirò.

In C ++ l'operatore "^" è un OR bit a bit. Non funziona per elevarsi al potere. X << n è uno spostamento a sinistra del numero binario che equivale a moltiplicare x per 2 n numero di volte e che può essere utilizzato solo aumentando 2 a una potenza. La funzione POW è una funzione matematica che funzionerà genericamente.

Dovresti essere in grado di usare i normali metodi C in matematica.

#include <cmath>

pow(2,3)

se sei su un sistema simile a unix, man cmath

È quello che stai chiedendo?

Sujal

Utilizzare la funzione pow (x, y): vedere qui

Includi solo math.h e sei pronto.

Sebbene pow( base, exp )sia un ottimo suggerimento, tieni presente che in genere funziona in virgola mobile.

Questo può essere o meno quello che vuoi: su alcuni sistemi un semplice ciclo che si moltiplica su un accumulatore sarà più veloce per i tipi interi.

E per il quadrato in particolare, potresti anche moltiplicare i numeri da solo, in virgola mobile o intero; non è in realtà una riduzione della leggibilità (IMHO) ed eviti il ​​sovraccarico di prestazioni di una chiamata di funzione.

Non ho abbastanza reputazione per commentare, ma se ti piace lavorare con QT, hanno la loro versione.

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

O se non stai usando QT, cmath ha sostanzialmente la stessa cosa.

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

// definizione della funzione raiseToPower

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

se vuoi avere a che fare solo con base_2 allora ti consiglio di usare l'operatore di spostamento a sinistra << invece della libreria matematica .

codice di esempio :

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

uscita campione:

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

È pow o powf in <math.h>

Non esiste un operatore infix speciale come in Visual Basic o Python

Molte risposte hanno suggerito pow()alternative simili o loro implementazioni. Tuttavia, date le esempi ( 2^1, 2^2e 2^3) nella sua domanda, direi se avete solo bisogno di rilancio 2ad una potenza intera. In questo caso, ti suggerirei di utilizzare 1 << nper 2^n.

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

Il titolo della domanda originale è fuorviante. Per quadrare , usa 2*2.

Si noti che l'utilizzo di pow(x,y)è meno efficiente di x*x*xy volte, come mostrato e risposto qui https://stackoverflow.com/a/2940800/319728 .

Quindi, se hai intenzione di usare l'efficienza 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

Sto usando la biblioteca cmatho math.hper usare le pow()funzioni della biblioteca che si occupano dei poteri

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

Prima aggiungi #include <cmath>quindi puoi usare powmethode nel tuo codice, ad esempio:

pow(3.5, 3);

Quale 3.5 è base e 3 è exp

usa la funzione pow () nella libreria cmath, tgmath o 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;
}

si noti che se si dà input al potere come qualsiasi tipo di dati diverso dal doppio lungo, la risposta verrà promossa a quella del doppio. cioè prenderà input e darà output come doppio. per ingressi doppi lunghi il tipo di ritorno è double double. per cambiare la risposta a int use, int c = (int) pow (a, b)

Tuttavia, tieni presente che per alcuni numeri ciò può comportare un numero inferiore alla risposta corretta. quindi ad esempio devi calcolare 5 ^ 2, quindi la risposta può essere restituita come 24.99999999999 su alcuni compilatori. cambiando il tipo di dati in int la risposta sarà 24 anziché 25 la risposta corretta. Quindi, fai questo

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

Ora la tua risposta sarà corretta. inoltre, per numeri molto grandi i dati vengono persi cambiando il tipo di dati da double a long long int. per esempio scrivi

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

e dai un input a = 3 e b = 38, il risultato sarà 1350851717672992000 mentre la risposta corretta è 1350851717672992089, ciò accade perché la funzione pow () restituisce 1.35085e + 18 che viene promossa a int come 1350851717672992000. Suggerisco di scrivere un funzione di alimentazione personalizzata per tali scenari, come: -

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

e poi chiamandolo quando vuoi,

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

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

return 0;
}

Per numeri maggiori dell'intervallo di long long int, utilizzare la libreria boost o le stringhe.