Qual é a função C ++ para elevar um número a uma potência?

Como elevo um número a uma potência?

2^1

2^2

2^3

etc ...

pow () na biblioteca cmath. Mais informações aqui . Não se esqueça de colocar #include<cmath>no topo do arquivo.

std::powno <cmath>cabeçalho tem estas sobrecargas:

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

Agora você não pode simplesmente fazer

pow(2, N)

com N sendo um int, porque ele não sabe qual das float, doubleou long doublea versão que deve tomar, e você terá um erro de ambiguidade. Todos os três precisariam de uma conversão de int para ponto flutuante, e todos os três são igualmente caros!

Portanto, certifique-se de digitar o primeiro argumento para que ele corresponda perfeitamente a um desses três. Eu costumo usardouble

pow(2.0, N)

Algum advogado me cagou de novo. Muitas vezes eu já caí nessa armadilha, então vou avisá-lo sobre isso.

Em C ++, o operador "^" é um OR bit a bit. Não funciona para aumentar a potência. X << n é um deslocamento à esquerda do número binário, que é o mesmo que multiplicar x por 2 n número de vezes e que só pode ser usado ao elevar 2 à potência. A função POW é uma função matemática que funcionará genericamente.

Você deve poder usar métodos C normais em matemática.

#include <cmath>

pow(2,3)

se você estiver em um sistema unix, man cmath

É isso que você está perguntando?

Sujal

Use a função pow (x, y): veja aqui

Basta incluir math.h e está tudo pronto.

Embora pow( base, exp )seja uma ótima sugestão, saiba que normalmente funciona em ponto flutuante.

Isso pode ou não ser o que você deseja: em alguns sistemas, um loop simples que se multiplica em um acumulador será mais rápido para tipos inteiros.

E para o quadrado especificamente, você também pode multiplicar os números, ponto flutuante ou número inteiro; não é realmente uma diminuição na legibilidade (IMHO) e você evita a sobrecarga de desempenho de uma chamada de função.

Não tenho reputação suficiente para comentar, mas se você gosta de trabalhar com o QT, eles têm sua própria versão.

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

Ou, se você não estiver usando o QT, o cmath tem basicamente a mesma coisa.

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

// definição da função 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 você quiser lidar apenas com base_2 , recomendo usar o operador de deslocamento à esquerda << em vez da biblioteca de matemática .

Código de amostra :

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

saída de amostra:

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

É powf ou powf em <math.h>

Não há operador de infixo especial como no Visual Basic ou Python

Muitas respostas sugeriram pow()alternativas semelhantes ou suas próprias implementações. No entanto, dados os exemplos ( 2^1, 2^2e 2^3) em sua pergunta, eu acho que você só precisa aumentar 2para uma potência inteira. Se este for o caso, eu sugiro que você usar 1 << npara 2^n.

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

O título da sua pergunta original é enganoso. Para apenas quadrado , use 2*2.

Observe que o uso de pow(x,y)é menos eficiente que x*x*xy vezes, como mostrado e respondido aqui https://stackoverflow.com/a/2940800/319728 .

Então, se você estiver indo para o uso eficiente 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

Estou usando a biblioteca cmath ou math.hpara fazer uso das pow()funções da biblioteca que cuidam dos poderes

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

Primeiro adicione, #include <cmath>então você pode usar o powmethode no seu código, por exemplo:

pow(3.5, 3);

Qual 3,5 é base e 3 é exp

use a função pow () na biblioteca 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;
}

observe que, se você fornecer entrada para poder como qualquer tipo de dado que não seja o dobro longo, a resposta será promovida para o dobro. ou seja, ele aceitará e dará saída como o dobro. para entradas longas longas, o tipo de retorno é longo duplo. para alterar a resposta para uso int, int c = (int) pow (a, b)

Porém, lembre-se de que alguns números podem resultar em um número menor que a resposta correta. portanto, por exemplo, você deve calcular 5 ^ 2, e a resposta pode ser retornada como 24.99999999999 em alguns compiladores. ao alterar o tipo de dados para int, a resposta será 24, em vez de 25, a resposta correta. Então faça isso

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

Agora, sua resposta estará correta. Além disso, para números muito grandes, os dados são perdidos ao alterar o tipo de dados duplo para longo, int longo. por exemplo você escreve

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

e forneça a entrada a = 3 eb = 38, o resultado será 1350851717672992000, enquanto a resposta correta é 135085171767299202089, isso ocorre porque a função pow () retorna 1.35085e + 18, que é promovida para int como 1350851717672992000. Sugiro escrever um função de energia personalizada para esses cenários, como:

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 depois chamá-lo quando quiser,

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

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

return 0;
}

Para números maiores que o intervalo de long long int, use a biblioteca de reforço ou as strings.