Programando en C++ no.6: creando una simple calculadora

En esta ocasión crearemos una calculadora para obtener el IMC y pulsaciones de una persona.

1. El programa tendrá un menú con tres opciones (cálculo del IMC, cálculo de pulsaciones y salida). 
2. Tendrá un encabezado: calculo.hpp 
3. Un programa de implementación de ese encabezado: calculo.cpp 
4. Un programa main: main.cpp

El programa solicitará estos datos:

• nombre.
• peso.
• talla.
• edad. 
• género.

Definamos el encabezado. Recordemos que al ser C++ la extensión puede ser tanto *.h como *.hpp.

calculos.hpp

#ifndef CALCULOS_H
#define CALCULOS_H

#endif

En este archivo importaremos las librerías necesarias:

#ifndef CALCULOS_H
#define CALCULOS_H

#include <ctime>
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;


#endif

También podemos definir "constantes" de esta forma:

#ifndef CALCULOS_H
#define CALCULOS_H

#define HOMBRE_PULS 220
#define MUJER_PULS 226
#define OPC_1 1
#define OPC_2 2

#include <ctime>
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;


#endif

Dentro del encabezado crearemos una clase para contener lo datos solicitados:

#ifndef CALCULOS_H
#define CALCULOS_H

#define HOMBRE_PULS 220
#define MUJER_PULS 226
#define OPC_1 1
#define OPC_2 2

#include <ctime>
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;


class Register
{
private:
    time_t hora_dia;
    string nombre;
    int edad;
    double talla;
    double peso;

public:
    Register() : hora_dia(time(nullptr)), nombre(""), edad(0), talla(0.0), peso(0.0) {}

    Register(const string &nombre_, int edad_, double talla_, double peso_)
        : hora_dia(time(nullptr)), nombre(nombre_), edad(edad_), talla(talla_), peso(peso_) {}

    time_t getHoraDia() const { return hora_dia; }
    string getNombre() const { return nombre; }
    int getEdad() const { return edad; }
    double getTalla() const { return talla; }
    double getPeso() const { return peso; }

    void setNombre(const string &nombre_) { nombre = nombre_; }
    void setEdad(int edad_) { edad = edad_; }
    void setTalla(double talla_) { talla = talla_; }
    void setPeso(double peso_) { peso = peso_; }
    void setHoraDia(time_t hora_) { hora_dia = hora_; }

    void mostrar() const
    {
        tm *tiempo_local = localtime(&hora_dia);
        cout << "Registro:" << endl;
        cout << "Nombre: " << nombre << endl;
        cout << "Edad: " << edad << " años" << endl;
        cout << "Talla: " << talla << " m" << endl;
        cout << "Peso: " << peso << " kg" << endl;
        cout << "Hora del día: " << put_time(tiempo_local, "%Y-%m-%d %H:%M:%S") << endl;
    }
};

#endif

Esta clase tiene los atributos de nombre, edad, talla, peso y definimos un campo de hora. Además de contar con sus setters y getters, y un método para mostrar todos los datos.

Definamos ahora los encabezados de las funciones para calcular el IMC, las pulsaciones, el menú, y la introducción de datos.

calculos.hpp

#ifndef CALCULOS_H
#define CALCULOS_H

#define HOMBRE_PULS 220
#define MUJER_PULS 226
#define OPC_1 1
#define OPC_2 2

#include <ctime>
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

class Register
{
private:
    time_t hora_dia;
    string nombre;
    int edad;
    double talla;
    double peso;

public:
    Register() : hora_dia(time(nullptr)), nombre(""), edad(0), talla(0.0), peso(0.0) {}

    Register(const string &nombre_, int edad_, double talla_, double peso_)
        : hora_dia(time(nullptr)), nombre(nombre_), edad(edad_), talla(talla_), peso(peso_) {}

    time_t getHoraDia() const { return hora_dia; }
    string getNombre() const { return nombre; }
    int getEdad() const { return edad; }
    double getTalla() const { return talla; }
    double getPeso() const { return peso; }

    void setNombre(const string &nombre_) { nombre = nombre_; }
    void setEdad(int edad_) { edad = edad_; }
    void setTalla(double talla_) { talla = talla_; }
    void setPeso(double peso_) { peso = peso_; }
    void setHoraDia(time_t hora_) { hora_dia = hora_; }

    void mostrar() const
    {
        tm *tiempo_local = localtime(&hora_dia);
        cout << "Registro:" << endl;
        cout << "Nombre: " << nombre << endl;
        cout << "Edad: " << edad << " años" << endl;
        cout << "Talla: " << talla << " m" << endl;
        cout << "Peso: " << peso << " kg" << endl;
        cout << "Hora del día: " << put_time(tiempo_local, "%Y-%m-%d %H:%M:%S") << endl;
    }
};

void limpiarPantalla(void);
void introduceDatos(void);
double getIMC(double peso, double talla);
double getPulsaciones(int edad);
void inicia(void);
int menu(void);
void obtenerCalcImc(Register r1);
void obtenerCalcPuls(Register r1);
std::string clasificarIMC(double imc);

#endif

Con esto terminamos el archivo de encabezados. Ahora continuaremos con el programa implementador.

calculos.cpp

#include "calculos.hpp"

En este importaremos el encabezado. Además de implementar cada una de las funciones declararas en el encabezado.

calculos.cpp

#include "calculos.hpp"

double getIMC(double peso, double talla)
{
    return peso / (talla * talla);
}

double getPulsaciones(int edad)
{
    if (OPC_1 == 1)
    {
        return HOMBRE_PULS - (0.7 * edad);
    }
    else if (OPC_2 == 2)
    {
        return MUJER_PULS - (0.8 * edad);
    }
    else
    {
        return 0.0;
    }
}

std::string clasificarIMC(double imc)
{
    std::string cad = "";

    if (imc < 16.00)
    {
        cad = "Infrapeso: Delgadez Severa";
    }
    else if (imc <= 16.99)
    {
        cad = "Infrapeso: Delgadez moderada";
    }
    else if (imc <= 18.49)
    {
        cad = "Infrapeso: Delgadez aceptable";
    }
    else if (imc <= 24.99)
    {
        cad = "Peso Normal";
    }
    else if (imc <= 29.99)
    {
        cad = "Sobrepeso";
    }
    else if (imc <= 34.99)
    {
        cad = "Obeso: Tipo I";
    }
    else if (imc <= 35.00 || imc == 40.00)
    {
        cad = "Obeso: Tipo III";
    }
    else
    {
        cad = "no existe clasificacion";
    }

    return cad;
}

void obtenerCalcImc(Register r1)
{
    double imc = getIMC(r1.getPeso(), r1.getTalla());
    r1.mostrar();
    cout << "El IMC es de " << imc << " kg/(m*m)" << endl;
    cout << "Diagnostico: " << clasificarIMC(imc) << endl;
}

void limpiarPantalla() {
#ifdef _WIN32
    system("cls");
#else
    system("clear");
#endif
}


void obtenerCalcPuls(Register r1)
{   r1.mostrar();
    cout << "El no. de pulsaciones es de " << getPulsaciones(r1.getEdad()) << " por minuto." << endl;
}

int menu()
{
    int opc;
    cout << "\t *******  MENU ******" << endl;
    cout << "\t 1. Obtener IMC." << endl;
    cout << "\t 2. Obtener pulsaciones." << endl;
    cout << "\t 3. Salir." << endl;
    do
    {
        cout << "Introduce opcion:" << endl;
        cin >> opc;
    } while (opc < 0 || opc > 3);
    return opc;
}


string nombre;
double peso, talla;
int edad, genero;
Register r1;
void introduceDatos()
{
    cout << "\t *********************************" << endl;
    cout << "Introduce nombre de la persona: " << endl;
    cin >> nombre;
    cout << "Introduce talla: " << endl;
    cin >> talla;
    cout << "Introduce peso: " << endl;
    cin >> peso;
    cout << "Introduce edad: " << endl;
    cin >> edad;
    cout << "Introduce tu genero [Masculino: 1,  Femenino: 2]:" << endl;
    cin >> genero;
    cout << "\t *********************************" << endl;
    r1.setNombre(nombre);
    r1.setEdad(edad);
    r1.setTalla(talla);
    r1.setPeso(peso);
}

void inicia(void)
{
    limpiarPantalla();
    int opcion = 0; 
    for (;;)
    {
        opcion = menu();
        cout << "Tu opcion fue: " << opcion << endl;
        switch (opcion)
        {
        case 1:
            introduceDatos();
            obtenerCalcImc(r1);
            break;
        case 2:
            introduceDatos();
            obtenerCalcPuls(r1);
            break;
        case 3:
            exit(0);
            break;
        }
    }
}

¿Qué podemos ver en este archivo?

• Hemos implementado cada una de las funciones declaradas en el encabezado.
• Estas funciones comprenden el menú del programa.
• La introducción de opciones a elegir y datos del usuario.
• El cálculo de cada operación y el resultado.

Miremos ahora el programa main:

main.cpp

#include "calculos.cpp"

int main(int argc, char const *argv[])
{
    inicia();
    return 0;
}

Este solo hace una importación del archivo implementador (calculos.cpp) e invoca la función que dispara la ejecución del programa (función inicia).

¿Qué sigue?

Compilamos:

$ g++ main.cpp -o calculadora.exe

Ejecutamos:

$ calculadora.exe

Salida:

         *******  MENU ******
         1. Obtener IMC.
         2. Obtener pulsaciones.
         3. Salir.
Introduce opcion:
1
Tu opcion fue: 1
         *********************************
Introduce nombre de la persona:
THOMAS
Introduce talla:
1.78
Introduce peso:
73
Introduce edad:
44
Introduce tu genero [Masculino: 1,  Femenino: 2]:
1
         *********************************
Registro:
Nombre: THOMAS
Edad: 44 a├▒os
Talla: 1.78 m
Peso: 73 kg
Hora del día: 2025-10-25 13:05:05
El IMC es de 23.04 kg/(m*m)
Diagnostico: Peso Normal
         *******  MENU ******
         1. Obtener IMC.
         2. Obtener pulsaciones.
         3. Salir.

Si elegimos la opción 2:

         *******  MENU ******
         1. Obtener IMC.
         2. Obtener pulsaciones.
         3. Salir.
Introduce opcion:
2
Tu opcion fue: 2
         *********************************
Introduce nombre de la persona:
MARIA
Introduce talla:
1.66
Introduce peso:
65
Introduce edad:
32
Introduce tu genero [Masculino: 1,  Femenino: 2]:
2
         *********************************
Registro:
Nombre: MARIA
Edad: 32 a├▒os
Talla: 1.66 m
Peso: 65 kg
Hora del día: 2025-10-25 13:06:30
El no. de pulsaciones es de 197.6 por minuto.
         *******  MENU ******
         1. Obtener IMC.
         2. Obtener pulsaciones.
         3. Salir.

¿Qué hemos visto?

• Como crear un programa en C++ mediante "módulos". 
• Como crear clases e instanciar objetos de esa clase. 
• Como crear archivos encabezados (calculos.hpp). 
• Como implementar las funciones definidas en ese archivo de encabezados (calculos.cpp). 
• Como invocar funciones que disparen una acción desde un programa main (main.cpp).

Enlaces:

https://codemonkeyjunior.blogspot.com/2025/10/creando-una-aplicacion-web-sencilla-con.html
https://codemonkeyjunior.blogspot.com/2024/06/hace-tiempo-vimos-como-crear-un.html

Consumiendo una API pública con Kotlin & OkHttp

En el pasado post vimos cómo consumir un servicio Node desde una aplicación Java gracias a la librería OkHttp. Esta vez usaremos Kotlin como lenguaje base y Gradle para la administración de las dependencias y ejecución del proyecto.

¿Qué haremos?

• Crear una aplicación Kotlin con Gradle. 
• Consumir una API pública: https://api.chucknorris.io/jokes/random

1. Comenzaremos con la creación del directorio del proyecto:

$ mkdir proyecto-kotlin
$ cd proyecto-kotlin

El directorio del proyecto se verá así:

proyecto-kotlin/
   .gitattributes
   .gitignore
   .gradle
   .kotlin
   app/
   build/
   gradle/
   gradle.properties
   gradlew
   gradlew.bat
   settings.gradle.kts

2. Agregamos la dependencia de ``OkHttp`` en el archivo ``build.gradle.kts``:

plugins {
    alias(libs.plugins.kotlin.jvm)
    application
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("com.squareup.okhttp3:okhttp:4.12.0") // Moved to implementation
    testImplementation("org.jetbrains.kotlin:kotlin-test")
    testImplementation(libs.junit.jupiter.engine)
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
    implementation(libs.guava)
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.3")
    testImplementation("org.mockito:mockito-core:5.12.0")
    testImplementation("org.mockito:mockito-junit-jupiter:5.12.0")
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

application {
    mainClass = "org.inforhomex.AppKt"
}

tasks.named<Test>("test") {
    useJUnitPlatform()
}

Con esto se podrá descargar la dependencia.

3. Editamos el programa ``app/src/main/kotlin/org/inforhomex/App.kt``.

package org.inforhomex

import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.IOException

private const val URL_API = "https://api.chucknorris.io/jokes/random"

fun run(client: OkHttpClient = OkHttpClient()) {
    val request = Request.Builder().url(URL_API).build()
    client.newCall(request).execute().use { response ->
        if (!response.isSuccessful) throw IOException("Unexpected code $response")
        for ((name: String, value: String) in response.headers) {
            println("$name: $value")
        }
        println(response.body?.string() ?: "No response body")
    }
}

fun main() {
    run()
}

4. Creamos una prueba unitaria ``AppTest.kt``

package org.inforhomex


import okhttp3.*
import okio.Buffer
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.junit.jupiter.MockitoExtension
import java.io.IOException
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith

@ExtendWith(MockitoExtension::class)
class AppTest {

    @Mock
    private lateinit var client: OkHttpClient

    @Mock
    private lateinit var response: Response

    @Mock
    private lateinit var responseBody: ResponseBody

    @Mock
    private lateinit var call: Call

    private val urlApi = "https://api.chucknorris.io/jokes/random"

    @BeforeEach
    fun setUp() {
        
        Mockito.`when`(client.newCall(Mockito.any(Request::class.java))).thenReturn(call)
    }

    @Test
    fun `test run success response`() {
        
        val mockJson = """
            {
                "icon_url": "https://assets.chucknorris.host/img/avatar/chuck-norris.png",
                "id": "abc123",
                "url": "",
                "value": "Chuck Norris can divide by zero."
            }
        """
        Mockito.`when`(call.execute()).thenReturn(response)
        Mockito.`when`(response.isSuccessful).thenReturn(true)
        Mockito.`when`(response.body).thenReturn(responseBody)
        Mockito.`when`(responseBody.string()).thenReturn(mockJson)
        Mockito.`when`(response.headers).thenReturn(Headers.Builder().add("Content-Type", "application/json").build())

        
        val output = captureOutput {
            run(client) 
        }

        
        assert(output.contains("Content-Type: application/json"))
        assert(output.contains("Chuck Norris can divide by zero."))
    }

    @Test
    fun `test run unsuccessful response throws IOException`() {
       
        Mockito.`when`(call.execute()).thenReturn(response)
        Mockito.`when`(response.isSuccessful).thenReturn(false)
        Mockito.`when`(response.code).thenReturn(404)

       
        val exception = assertFailsWith<IOException> {
            run(client) 
        }
        assertEquals("Unexpected code 404", exception.message)
    }

    
    private fun captureOutput(block: () -> Unit): String {
        val outputStream = java.io.ByteArrayOutputStream()
        val printStream = java.io.PrintStream(outputStream)
        val originalOut = System.out
        System.setOut(printStream)
        try {
            block()
        } finally {
            System.setOut(originalOut)
        }
        return outputStream.toString()
    }
}

5. Compilamos y ejecutamos la aplicación:

$ gradle build
$ gradle run

Si todo va bien, veremos esto en la consola:

date: Sun, 19 Oct 2025 03:25:17 GMT
content-type: application/json
nel: {"report_to":"heroku-nel","response_headers":["Via"],"max_age":3600,"success_fraction":0.01,"failure_fraction":0.1}
report-to: {"group":"heroku-nel","endpoints":[{"url":"https://nel.heroku.com/reports?s=e%2BRTonTfjrgED0WXfh1o2mxbl6%2BLhQQ4LIu%2F1NhF4MM%3D\u0026sid=812dcc77-0bd0-43b1-a5f1-b25750382959\u0026ts=1760844317"}],"max_age":3600}
reporting-endpoints: heroku-nel="https://nel.heroku.com/reports?s=e%2BRTonTfjrgED0WXfh1o2mxbl6%2BLhQQ4LIu%2F1NhF4MM%3D&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&ts=1760844317"
server: cloudflare
vary: Origin
vary: Access-Control-Request-Method
vary: Access-Control-Request-Headers
via: 1.1 heroku-router
cf-cache-status: DYNAMIC
cf-ray: 990d2ad69c2f69de-DFW
alt-svc: h3=":443"; ma=86400
{"categories":[],"created_at":"2020-01-05 13:42:20.262289","icon_url":"https://api.chucknorris.io/img/avatar/chuck-norris.png","id":"zDUih4UaS82sDRjSX0hlLQ","updated_at":"2020-01-05 13:42:20.262289","url":"https://api.chucknorris.io/jokes/zDUih4UaS82sDRjSX0hlLQ","value":"Chuck Norris always wanted to surf but couldn't. Everytime his board touches the water, the sea parts."}

¡La aplicación ha funcionado correctamente!

Continuaremos con esta serie de ejemplos en próximas entregas.

Enlaces:

https://square.github.io/okhttp/
https://www.baeldung.com/guide-to-okhttp
https://ironpdf.com/es/java/blog/java-help/okhttp-java/