Le langage C++ fournit une fonction « pow() » qui aide à trouver la puissance de n'importe quel nombre. Nous utilisons cette fonction lorsque nous voulons trouver la puissance du nombre en C++. Cette fonction prend deux arguments : le premier argument est la « base » ou le nombre dont nous voulons trouver la puissance et le prochain argument est l'exposant dans cette fonction. Cette fonction « pow() » est définie dans le fichier d'en-tête « math.h » ou « cmath » en programmation C++. Faisons quelques codes et vérifions comment cette méthode calcule la puissance de différents nombres en C++.
Exemple 1:
Les fichiers d'en-tête sont inclus en premier : « iostream » et « cmath ». Le « iostream » est inclus en entrée/sortie et les autres fonctions y sont définies. Le « cmath » est inclus car nous devons trouver la puissance d'un nombre à l'aide de la fonction « pow() » qui est définie dans ce fichier d'en-tête. Ensuite, nous devons ajouter l'espace de noms « std » afin de ne pas avoir besoin de l'ajouter avec les fonctions séparément.
En dessous, nous invoquons la méthode « main() », puis imprimons du texte en utilisant « cout » car cela facilite l'impression en C++. Ensuite, nous utilisons la fonction « pow() » dans laquelle nous plaçons « 5 » comme premier paramètre qui est ici la « base ». Ensuite, nous plaçons « 3 » comme deuxième paramètre qui est « l’exposant » de ce nombre. Maintenant, cette fonction « pow() » trouve la puissance du nombre « 5 » qui est élevée à la puissance « 3 » et affiche le résultat de puissance lorsque nous mettons cette fonction « pow() » à l'intérieur du « cout ».
Codage 1 :
#include
#inclure
en utilisant l'espace de noms std ;
int main ( ) {
cout << 'Nous calculons ici la puissance du nombre !' << fin;
cout << pouf ( 5 , 3 ) ;
retour 0 ;
}
Sortir:
La réponse de « 5 » élevé à la puissance « 3 » est « 125 » qui est également rendue dans ce qui suit. On obtient ce résultat à l'aide de la fonction « pow() ».
Exemple 2 :
Les fichiers d'en-tête « iostream » ainsi que « cmath » sont inclus ici. Ensuite, le « namespace std » est placé. En dessous, le « main() » est appelé. Ensuite, nous déclarons trois variables qui sont « valeur », « exposant » et « résultat » comme type de données « int ». Maintenant, nous attribuons « 6 » à la variable « valeur » et « 5 » à la variable « exposant ».
Après cela, nous utilisons la fonction « pow() ». Ensuite, nous passons les deux variables à cette fonction « pow() » et attribuons son résultat à la variable « outcome ». Après cela, nous utilisons le « cout » et imprimons d’abord la déclaration ici. Ensuite, dans le « cout » suivant, nous affichons la « valeur », « l'exposant », ainsi que le « résultat ».
Code 2 :
#include#inclure
en utilisant l'espace de noms std ;
int main ( ) {
valeur int, exposant, résultat ;
valeur = 6 ;
exposant = 5 ;
résultat = puissance ( valeur, exposant ) ;
cout << 'Nous utilisons ici la fonction pow !' << fin;
cout << valeur << '^' << exposant << ' = ' << résultat;
retour 0 ;
}
Sortir:
La fonction « pow() » nous aide à arriver à la réponse « 6 » élevée à la puissance « 5 » qui est « 7776 » comme présenté dans ce qui suit :
Exemple 3 :
Dans ce code, nous trouverons la puissance du nombre flottant où l'exposant est également le type de données flottant. Ici, « namespace std » est inséré après l'inclusion des fichiers d'en-tête « iostream » et « cmath ». La fonction « main() » est ensuite appelée et trois variables nommées « n_value », « e_value » et « p_result » sont déclarées comme type de données « float ». Nous définissons maintenant la variable « n_value » sur « 8.2 » et la variable « e_value » sur « 3.2 ».
Ensuite, nous utilisons la fonction « pow() », en lui passant les deux variables et en attribuant la sortie de la fonction à la variable « p_result ». Ensuite, nous utilisons la fonction « cout » pour imprimer la déclaration. Dans le « cout » suivant, nous afficherons les « n_value », « e_value » et « p_result » comme suit :
Code 3 :
#include#inclure
en utilisant l'espace de noms std ;
int main ( ) {
float n_value, e_value, p_result ;
n_valeur = 8.2 ;
e_value = 3.2 ;
p_result = pow ( n_value, e_value ) ;
cout << 'Nous utilisons ici la fonction pow !' << fin;
cout << n_valeur << '^' << e_value << ' = ' << p_result;
retour 0 ;
}
Sortir:
Voici le résultat dans lequel on trouve la puissance du nombre flottant dont l'exposant est aussi le nombre flottant avec l'aide de la fonction « pow() ».
Exemple 4 :
Ce code calcule la puissance du nombre double avec l'exposant comme type de données double. Dans ce cas, les fichiers d'en-tête « iostream » et « cmath » sont inclus avant que le « namespace std » ne soit inclus. Le code suivant appelle la fonction « main() » et déclare trois variables avec le type de données « double » : « d_Num », « d_Expo » et « d_PowRes ». Les variables « d_num » et « d_expo » sont désormais initialisées respectivement avec « 2.25 » et « 5.21 ».
Ensuite, nous attribuons la sortie de la fonction « pow() » à la variable « d_PowRes » et utilisons la fonction « pow() », en lui passant les deux variables. Ensuite, nous imprimons la phrase ici en utilisant la fonction « cout ». Les « d_Num », « d_Expo » et « d_PowRes » sont affichés dans le « cout » suivant.
Code 4 :
#include#inclure
en utilisant l'espace de noms std ;
int main ( ) {
double d_Num, d_Expo , d_PowRes ;
d_Numéro = 2.25 ;
d_Expo = 5.21 ;
d_PowRes = puissance ( d_Num, d_Expo ) ;
cout << 'Nous utilisons ici la fonction pow !' << fin;
cout << 'Le nombre est ' << d_Num << ' Son exposant est ' << d_Expo << fin;
cout << d_Num << '^' << d_Expo << ' = ' << d_PowRes ;
retour 0 ;
}
Sortir:
Cela résulte de l'utilisation de la fonction « pow() » pour obtenir la puissance d'un nombre double dont l'exposant est également un nombre double.
Exemple 5 :
Dans ce dernier code, on retrouvera la puissance d'un nombre dont l'exposant est le nombre négatif. Les fichiers d'en-tête « bits/stdc++.h » et « math.h » sont inclus ici avec le fichier d'en-tête « iostream » dans ce code car le fichier d'en-tête « math.h » contient la définition de la fonction « pow() ».
Après cela, nous ajoutons l'espace de noms « std ». Ensuite, le « main() » est maintenant appelé. La variable « b » est initialisée ici comme type de données « float » et la valeur « 4,87 » est attribuée à cette variable. En dessous, la variable « int » « e » est initialisée avec la valeur négative qui est « -2 ». Ensuite, le « résultat flottant » est également déclaré ici. En dessous, nous initialisons cette variable « résultat » et attribuons la fonction « pow() » à cette variable dans laquelle les deux variables « b » et « e » sont placées comme paramètres.
Ici, nous insérons la base du type de données « float ». L'exposant est la valeur entière négative. Désormais, le résultat que nous obtenons après l'application de cette fonction est enregistré dans la variable « result » qui est affichée ci-dessous en utilisant le « cout » en dessous.
Code 5 :
#include#include
#include
en utilisant l'espace de noms std ;
int main ( ) {
flotter b = 4,87 ;
entier e = -2 ;
résultat flottant ;
résultat = puissance ( être ) ;
cout << 'L'exposant est négatif ici' << fin;
cout << b << '^' << C'est << ' = ' << résultat;
retour 0 ;
}
Sortir:
Cela donne le résultat où nous insérons l'exposant négatif au nombre de base flottant dans notre code. Nous obtenons ce résultat de puissance avec la fonction « pow() ».
Conclusion
La fonction « pow() » en C++ est explorée ici dans ce guide. Nous l'avons défini comme le calcul de la puissance de n'importe quel nombre lorsque nous utilisons cette fonction « pow() ». Nous avons également illustré plusieurs exemples d'application de cette fonction « pow() » sur le nombre de types de données différents en programmation C++. Nous avons également calculé la puissance du nombre où l'exposant est la valeur négative et rendu les sorties de tout le code dans ce guide.