A linguagem C++ fornece uma função “pow()” que ajuda a encontrar a potência de qualquer número. Utilizamos esta função quando queremos encontrar a potência do número em C++. Esta função leva dois argumentos: o primeiro argumento é a “base” ou o número cuja potência queremos encontrar e o próximo argumento é o expoente nesta função. Esta função “pow()” é definida dentro do arquivo de cabeçalho “math.h” ou “cmath” na programação C++. Vamos fazer alguns códigos e verificar como este método calcula a potência de diferentes números em C++.
Exemplo 1:
Os arquivos de cabeçalho são incluídos primeiro: “iostream” e “cmath”. O “iostream” está incluído como entrada/saída e as demais funções são definidas nele. O “cmath” está incluído porque temos que encontrar a potência de um número com o auxílio da função “pow()” que está definida neste arquivo de cabeçalho. Então, devemos adicionar o namespace “std” para que não precisemos adicioná-lo com as funções separadamente.
Abaixo disso, invocamos o método “main()” e então imprimimos algum texto usando o “cout”, pois auxilia na impressão em C++. Em seguida, utilizamos a função “pow()” na qual colocamos “5” como o primeiro parâmetro que é a “base” aqui. Então, colocamos “3” como o segundo parâmetro que é o “expoente” desse número. Agora, esta função “pow()” encontra a potência do número “5” que é elevado à potência de “3” e exibe o resultado da potência conforme colocamos esta função “pow()” dentro de “cout”.
Código 1:
#include
#incluir
usando namespace std;
principal interno ( ) {
corte << 'Estamos calculando o poder do número aqui!' << fim;
corte << Pancada ( 5 , 3 ) ;
retornar 0 ;
}
Saída:
A resposta de “5” elevada à potência “3” é “125”, que também é traduzida a seguir. Obtemos esse resultado com o auxílio da função “pow()”.
Exemplo 2:
Os arquivos de cabeçalho “iostream” e “cmath” estão incluídos aqui. Em seguida, o “namespace std” é colocado. Abaixo disso, o “main()” é chamado. Em seguida, declaramos três variáveis que são “valor”, “expoente” e “resultado” como o tipo de dados “int”. Agora, atribuímos “6” à variável “valor” e “5” à variável “expoente”.
Depois disso, utilizamos a função “pow()”. Em seguida, passamos ambas as variáveis para esta função “pow()” e atribuímos seu resultado à variável “resultado”. Depois disso, utilizamos o “cout” e imprimimos a declaração aqui primeiro. Depois, no próximo “cout”, exibimos o “valor”, o “expoente”, bem como o “resultado”.
Código 2:
#include#incluir
usando namespace std;
principal interno ( ) {
valor interno, expoente, resultado;
valor = 6 ;
expoente = 5 ;
resultado = pow ( valor, expoente ) ;
corte << 'Utilizamos a função pow aqui!' << fim;
corte << valor << '^' << expoente << '=' << resultado;
retornar 0 ;
}
Saída:
A função “pow()” nos ajuda a chegar à resposta de “6” elevado à potência de “5”, que é “7776”, conforme apresentado a seguir:
Exemplo 3:
Neste código, encontraremos a potência do número flutuante onde o expoente também é o tipo de dados flutuante. Aqui, “namespace std” é inserido após a inclusão dos arquivos de cabeçalho “iostream” e “cmath”. A função “main()” é então chamada e três variáveis denominadas “n_value”, “e_value” e “p_result” são declaradas como o tipo de dados “float”. Agora definimos a variável “n_value” como “8,2” e a variável “e_value” como “3,2”.
Em seguida, usamos a função “pow()”, passando ambas as variáveis para ela e atribuindo a saída da função à variável “p_result”. A seguir, usamos a função “cout” para imprimir o extrato. No “cout” a seguir, mostraremos o “n_value”, “e_value” e “p_result” da seguinte forma:
Código 3:
#include#incluir
usando namespace std;
principal interno ( ) {
float n_valor, e_valor, p_resultado;
n_valor = 8.2 ;
e_valor = 3.2 ;
p_resultado = pow ( n_valor, e_valor ) ;
corte << 'Utilizamos a função pow aqui!' << fim;
corte << n_valor << '^' << e_valor << '=' << p_resultado;
retornar 0 ;
}
Saída:
Aqui está o resultado em que encontramos a potência do número flutuante cujo expoente também é o número flutuante com o auxílio da função “pow()”.
Exemplo 4:
Este código calcula a potência do número duplo com o expoente como tipo de dados duplo. Neste caso, os arquivos de cabeçalho “iostream” e “cmath” são incluídos antes que o “namespace std” seja incluído. O código a seguir chama a função “main()” e declara três variáveis com o tipo de dados “double” e estas são “d_Num”, “d_Expo” e “d_PowRes”. As variáveis “d_num” e “d_expo” agora são inicializadas com “2,25” e “5,21”, respectivamente.
A seguir, atribuímos a saída da função “pow()” à variável “d_PowRes” e usamos a função “pow()”, passando ambas as variáveis para ela. A seguir, imprimimos a frase aqui usando a função “cout”. O “d_Num”, “d_Expo” e “d_PowRes” são exibidos no “cout” seguinte.
Código 4:
#include#incluir
usando namespace std;
principal interno ( ) {
duplo d_Num, d_Expo, d_PowRes;
d_Número = 2,25 ;
d_Expo = 5.21 ;
d_PowRes = pow ( d_Num, d_Expo ) ;
corte << 'Utilizamos a função pow aqui!' << fim;
corte << 'O número é ' << d_Num << 'Seu expoente é' << d_Expo << fim;
corte << d_Num << '^' << d_Expo << '=' << d_PowRes;
retornar 0 ;
}
Saída:
Isso resulta do uso da função “pow()” para obter a potência de um número duplo cujo expoente também é um número duplo.
Exemplo 5:
Neste último código encontraremos a potência de um número cujo expoente é o número negativo. Os arquivos de cabeçalho “bits/stdc++.h” e “math.h” estão incluídos aqui junto com o arquivo de cabeçalho “iostream” neste código, pois o arquivo de cabeçalho “math.h” contém a definição da função “pow()”.
Depois disso, adicionamos o namespace “std”. Então, o “main()” agora é chamado. A variável “b” é inicializada aqui como o tipo de dados “float” e o valor “4,87” é atribuído a esta variável. Abaixo disso, a variável “int” “e” é inicializada com o valor negativo que é “-2”. Então, o “resultado flutuante” também é declarado aqui. Abaixo disso, inicializamos esta variável “resultado” e atribuímos a função “pow()” a esta variável na qual ambas as variáveis “b” e “e” são colocadas como parâmetros.
Aqui, inserimos a base do tipo de dados “float”. O expoente é o valor inteiro negativo. Agora, o resultado que obtemos após aplicar esta função é salvo na variável “resultado” que é exibida a seguir usando o “cout” abaixo dela.
Código 5:
#include#incluir
#include
usando namespace std;
principal interno ( ) {
flutuar b = 4,87 ;
int e = -2 ;
resultado flutuante;
resultado = pow ( ser ) ;
corte << 'O expoente é negativo aqui' << fim;
corte << b << '^' << e << '=' << resultado;
retornar 0 ;
}
Saída:
Isso renderiza o resultado onde inserimos o expoente negativo no número base flutuante em nosso código. Obtemos esse resultado de potência com a função “pow()”.
Conclusão
A função “pow()” em C++ é explorada aqui neste guia. Nós o definimos como calcular a potência de qualquer número onde utilizamos esta função “pow()”. Também ilustramos vários exemplos de aplicação desta função “pow()” nos números de diferentes tipos de dados na programação C++. Também calculamos a potência do número onde o expoente é o valor negativo e renderizamos as saídas de todo o código neste guia.