Tutoriales

Ejemplo de prisionero de guerra en C++

El lenguaje C++ proporciona la función «pow()» para ayudar a calcular la potencia de cualquier número. Podemos usar esta función cuando queramos elevar un número a una potencia en C++. Esta función toma dos parámetros: el primer parámetro es la «base» o el número cuya potencia queremos encontrar, y el siguiente parámetro es el exponente de la función. Esta función «pow()» se define en el archivo de encabezado «math.h» o «cmath» en la programación C++. Escribamos un código y verifiquemos cómo este método calcula las potencias de diferentes números en C++.

Ejemplo 1:

Primero incluya los archivos de encabezado: «iostream» y «cmath». «iostream» se incluye como entrada/salida y en él se definen otras funciones. Se incluye «cmath» porque debemos usar la función «pow()» definida en este archivo de encabezado para calcular la potencia del número. Luego, tenemos que agregar el espacio de nombres «std» para que no necesitemos agregarlo por separado de la función.

Debajo de esto, llamamos al método «main()» y luego imprimimos algo de texto usando «cout», ya que ayuda con la impresión en C++. Luego utilizamos la función «pow()», pasando «5» como primer parámetro, que aquí es la «base». Luego pasamos «3» como segundo argumento, el «exponente» del número. Ahora, esta función «pow()» calcula el número «5» elevado a la potencia de «3» y muestra el resultado de la potencia cuando ponemos esta función «pow()» en «cout».

Código 1:

#incluir
#incluir

Utilice el espacio de nombres estándar;
maestro de enteros() {

kut < «¡Estamos elevando este número a una potencia!» < Finalizar;
kut < prisionero de guerra(5, 3);

devolver ;
}

Producción:

La respuesta a «5» elevado a la potencia de «3» es «125», como se muestra a continuación. Obtenemos este resultado con la ayuda de la función «pow()».

Ejemplo 2:

Contiene los archivos de encabezado «iostream» y «cmath». Luego, coloque «espacio de nombres estándar». Debajo de esto, se llama «main()». Luego, declaramos las tres variables «valor», «exponente» y «comentario» como tipo de datos «int». Ahora asignamos «6» a la variable «valor» y «5» a la variable «exponente».

Después de eso, usamos la función «pow()». Luego pasamos dos variables a esta función «pow()» y asignamos su resultado a la variable «resultado». Después de eso usamos «cout» e imprimimos la declaración aquí primero. Luego, en el siguiente «cout», mostramos el «valor», el «índice» y el «resultado».

Código 2:

#incluir
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros () {
valor int, índice, resultado;
valor = 6;
índice = 5;
Resultado = prisionero de guerra(valor, índice);
kut < «¡Estamos usando la función pow aquí!» < Finalizar;
kut < valor < «^» < índice < «=» < resultado;

devolver ;
}

Producción:

La función «pow()» nos ayuda a obtener la respuesta a «6» elevado a la potencia de «5», que es «7776», como se muestra a continuación:

Ejemplo 3:

En este código, elevaremos un número de punto flotante a una potencia donde el exponente también sea un tipo de datos de punto flotante. Aquí, «namespace std» se inserta después de los archivos de encabezado «iostream» y «cmath». Luego llame a la función «main()» y declare las tres variables denominadas «n_value», «e_value» y «p_result» como el tipo de datos «flotante». Ahora, configuramos la variable «n_value» en «8.2» y la variable «e_value» en «3.2».

Luego usamos la función «pow()», le pasamos dos variables y asignamos la salida de la función a la variable «p_result». A continuación, utilizamos la función «cout» para imprimir la declaración. En el «cout» a continuación, mostraremos «n_value», «e_value» y «p_result» como se muestra a continuación:

Código 3:

#incluir
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros () {
Números de coma flotante n_value, e_value, p_result;
n_valor= 8.2;
e_valor=3.2;
p_result = poder de combate(valor_n, valor_e);
kut < «¡Estamos usando la función pow aquí!» < Finalizar;
kut < valor n < «^» < valor_e < «=» < p_resultado;
devolver ;
}

Producción:

Este es el resultado de usar la función «pow()» para encontrar la potencia de un número de punto flotante cuyo exponente también es un número de punto flotante.

Ejemplo 4:

Este código calcula la potencia de un número doble. El exponente es un tipo de datos doble. En este caso, incluya los archivos de encabezado «iostream» y «cmath» antes de incluir «namespace std». El siguiente código llama a la función «main()» y declara tres variables del tipo de datos «doble», a saber, «d_Num», «d_Expo» y «d_PowRes». Las variables «d_num» y «d_expo» ahora se inicializan en «2.25» y «5.21» respectivamente.

A continuación, asignamos la salida de la función «pow()» a la variable «d_PowRes» y utilizamos la función «pow()», pasándole las dos variables. A continuación, usamos la función «cout» para imprimir la oración aquí. «d_Num», «d_Expo» y «d_PowRes» se muestran en el siguiente «cout».

Código 4:

#incluir
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros () {
Doble d_Num, d_Expo, d_PowRes;
d_Núm = 2.25;
d_Expo= 5.21;
d_PowRes = poder de combate(d_Num, d_Expo);
kut < «¡Estamos usando la función pow aquí!» < Finalizar;
kut < «número es» < d_Núm < «Su índice es» < d_expo < Finalizar;
kut < d_Núm < «^» < d_expo < «=» < d_PowRes;
devolver ;
}

Producción:

Esto se debe al uso de la función «pow()» para obtener la potencia de un doble cuyo exponente también es doble.

Ejemplo 5:

En el código final, elevaremos los números con exponentes negativos a potencias. Los archivos de encabezado «bits/stdc++.h» y «math.h» se incluyen en el código junto con el archivo de encabezado «iostream» porque el archivo de encabezado «math.h» contiene la definición de la función «pow()».

Después de eso, agregamos el espacio de nombres «std». Entonces, ahora llama a «principal()». La variable «b» se inicializa aquí con el tipo de datos «flotante» y se le asigna el valor «4,87». Debajo de esto, la variable «int» «e» se inicializa al valor negativo «-2». Luego, aquí también se declara el «resultado flotante». A continuación, inicializamos la variable «resultado» y asignamos la función «pow()» a esta variable, con las variables «b» y «e» como parámetros.

Aquí insertamos la base del tipo de datos «flotante». Los exponentes son valores enteros negativos. Ahora, el resultado que obtenemos después de aplicar esta función se guarda en la variable «resultado» que se muestra a continuación usando «cout» a continuación.

Código 5:

#incluir
#incluir
#incluir
Utilice el espacio de nombres estándar;
maestro de enteros () {
flotador b = 4.87;
entero mi = -2;
resultado flotante;
Resultado = poder de combate();
kut < «El exponente aquí es negativo» < Finalizar;
kut < Segundo < «^» < mi < «=» < resultado;
devolver ;
}

Producción:

Esto generará el resultado de insertar un exponente negativo en una base de punto flotante en nuestro código. Obtenemos este resultado de potencia a través de la función «pow()».

en conclusión

Esta guía explorará la función «pow()» en C++. Lo definimos como calcular la potencia de cualquier número usando la función «pow()». También ilustramos varios ejemplos de aplicación de la función «pow()» a números de diferentes tipos de datos en programación C++. También calculamos las potencias de números con exponentes negativos y presentamos el resultado de todo el código en esta guía.

LEER  Revocación de privilegios SUDO de usuario en Linux

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba