El lenguaje de programación C

El mítico lenguaje de programación C sigue siendo el lenguaje que definió todo. Y con todo nos referimos a todo lo referente a la informática y programación. En épocas que ya no existen más, el programador de computadoras, término y profesión que aún no se consideraba algo serio, tenía que cambiar la configuración de la máquina para que realizará otras operaciones. Enormes máquinas que ocupaban salas enteras apenas estaban diseñadas para ciertas tareas muy específicas.

Con la llegada de los programas almacenados está tarea reducía en gran medida ese esfuerzo. Sin embargo, los lenguajes de programación estaban muy ligados a la arquitectura de la máquina. Los programas no podían ser compartidos. Si querías un programa para cálculos vectoriales en tu máquina, tendrías que programarlo de acuerdo a la arquitectura de tu máquina (sic).

Es ahí cuando llegan los lenguajes de alto nivel. Lenguajes que están a un paso de los lenguajes máquinas y que no están ligados a ciertas arquitecturas.

Dennis Ritchie ideó un lenguaje de programmación al que denominó simplemente C. Un lenguaje de programación muy rápido, eficiente y tiene un control directo sobre el hardware y la memoria.

Un lenguaje que inspiró a otros como Java, C++, C#, entre otros más (y la lista crece). Un lenguaje intermedio entre el lenguaje máquina y los de alto nivel.

¿Qué es el lenguaje C?

"C es un lenguaje de programación de propósito general que ofrece como ventajas ecnonomía de expresión, control de flujo y estructuras de datos modernos y un conjunto rico de operadores. Además, C no es un lenguaje de muy alto nivel ni grande y no está especializado en alguna área especial de aplicación."

Puedes instalar el compilador gcc. Se puede instalar tanto en Mac OS, Linux y Windows.

Compilador gcc

Abrimos una terminal y listamos la versión:

$ gcc --version

Listamos la ayuda disponible:

$ gcc --help

Hola, mundo en C

Ejemplo 1. Escribamos el famoso programa del "Hola, mundo" en C.

holamundo.c

#include<stdio.h>

int main(){
 puts("Hola, mundo en C.");
 return 0;
}

Compilaremos el programa:

$ gcc -o holamundo.exe holamundo.c
$ ./holamundo.exe

Salida:

Hola, mundo en C.

Tipos en C

El lenguaje de programación C es un lenguaje estáticamente tipado pero con un sistema de tipos débil (o permisivo), lo que significa que requiere declarar el tipo de cada variable antes de usarla, pero permite conversiones implícitas automáticas entre tipos de datos compatibles.

Algunos de los tipos en este lenguaje son:

• char 
• int 
• byte 
• short 
• float 
• double

También permite definir tipos propios con typedef TipoDato NombreNuevaVaariable.

Como en muchos otros lenguajes no aplica el dicho de "Una variable es una variable". Un número entero deberá ser declarado con tipo int, y su valor es entero, un número con coma flotante (float) causará un error de compilación.

Miremos un ejemplo de conversión implícita:

#include<stdio.h>

int main(){
 int numero = 45;
 float numero_float = (float) numero;
 printf("Numero int = %d\n", numero);
 printf("Numero float = %.2f\n", numero_float);
 printf("Casteo = %d\n", (int) numero_float);
 return 0;
}

Esto también lo podemos observar en lenguajes modernos como Java o C#.

Programación modular

Un módulo se considera como una colección de paquetes y sus dependencias. En C los proyectos pueden estar divididos por módulos. Un programa puede tener cierta dependencia de archivos externos o dentro de su mismo ámbito. Es usual ver proyecto C con archivos de encabezados (*.h) y su implementación así como programas tipo "main" quienes son los encargados de realizar las operaciones principales.

Esto se puede observar en lenguajes como Java, C#, Python, etc.

Punteros y asignación dinámica de memoria

En C debemos tener cuidado con los punteros. Estos nos sirven para almacenar y manipular direcciones de memoria de la computadora, en lugar de guardar un valor directo (como un número o un texto). Un mal uso puede causar daños al programa o incluso a nuestra máquina.

También hay que tener cuidado con el mecanismo de asignación dinámica de memoria, el cual se usa para reservar espacio en la memoria RAM mientras el programa se está ejecutando (en tiempo de ejecución), en lugar de definirlo de forma fija cuando se compila.

Ambas "técnicas" son indispensables en el lenguaje, no son una opción aunque así pareciera. Conforme un programa se hace más grande y complejo se verán las ventajas de esto.

En próximas entregas veremos más sobre este lenguaje.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/06/el-lenguaje-de-programacion-d.html
https://es.wikipedia.org/wiki/C_(lenguaje_de_programaci%C3%B3n)
https://www.mingw-w64.org/
https://sourceware.org/cygwin/

Beef y C3, dos lenguajes de programación que evolucionan a C

En este 2026 la programación será cada vez más díficil de aprender y enseñar. La I.A. ha surgido como una herramienta útil para el desarrollador moderno, aunque también un lastre para quienes no quieren evolucionar (o morir en el intento). Es por eso que es necesario el estudio y práctica de la programación.

Existen dos lenguajes llamados Beef y C3 respectivamente que prometen ser la evolución directa al lenguaje mítico C.

Beef se siente como un híbrido entre C++ y C#, con tooling propio y características modernas (tuplas, pattern matching, mixins, reflexión, compilación en caliente). Es ideal para quienes buscan un lenguaje nativo con ecosistema completo y mayor productividad.

La documentación oficial nos dice:

"Beef es un lenguaje de programación de código abierto multiparadigma de alto rendimiento centrado en la productividad del desarrollador".

Beef soporta programación orientada a objetos, funcional y estructurada.

Enfocado a la alta productividad y rendimiento, con fuerte integración C/C++. Busca ser un lenguaje moderno para aplicaciones nativas con tooling propio (IDE, depurador, profiler).

C3 es más conservador. Se mantiene muy cerca de C, pero añade mejoras puntuales (contratos, macros más potentes, genéricos claros, mejor manejo de errores). Es atractivo para proyectos que ya usan C y quieren evolucionar sin perder compatibilidad.

La documentación oficial nos dice:

"C3 es una evolución, no una revolución: el C-like para programadores a quienes les gusta C".

El paradigma de C3 es ser imperativo y estructurado, con extensiones modernas (contratos, macros, genéricos).

Se conidera así mismo como una evolución ergonómica de C, manteniendo compatibilidad total con ABI de C. Su meta es mejorar la seguridad y expresividad sin perder la familiaridad para programadores de C.

Cada uno tiene sus propias características y peculiaridades.

Filosofía de Beef

Se basa en:

• "Productividad sin sacrificar rendimiento". 
• Ofrece compilación incremental, detección de fugas en tiempo real, generación de código en tiempo de compilación y un IDE dedicado.
• Se centra en mejorar la experiencia del desarrollador.

Filosofía de C3

Se basa en:

• "Una evolución, no una revolución". 
• Mantiene la simplicidad y cercanía a C, pero añade contratos, macros semánticos, reflexión y manejo de errores más seguro. 
•  Busca ser C mejorado, no reemplazarlo.

Relación con C/C++

Beef:

• Interoperabilidad directa con librerías C/C++ (estáticas y dinámicas).
• Permite mezclar niveles de optimización en un mismo proyecto.
• Sintaxis inspirada en C#, pero con bajo nivel similar a C++.

C3:

• Compatibilidad ABI completa con C.
• Puede integrarse en proyectos C/C++ sin esfuerzo.
• Sintaxis muy cercana a C, con mejoras inspiradas en C++ pero sin su complejidad.

Instalación

Ambos lenguajes pueden ser instalados en plataformas Linux, Mac OS y Windows.

Este es el IDE de Beef

Hola mundo

Observemos el clásico programa de "Hola, mundo" escrito en ambos lenguajes.

Beef:

HolaMundo.bf

using System;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Hola, mundo en Beef!");
    }
}

Como se puede observar, la extensión de un programa Beef es *.bf.

Beef puede usarse desde una terminal o desde su IDE.

Podemos crear un proyecto con los siguientes comandos:

$ beef new HolaMundo

Coloca el código en HolaMundo/src/HolaMundo.bf

Ejecuta el proyecto:

$ beef run

C3:

holamundo.c3

module hola_mundo;
import std::io;

fn void main()
{
io::printn("Hola, mundo en C3!");
}

La extensión de un programa en C3 no podría ser otro que *.c3.

Tiene una cercanía más expresiva a C.

Compilamos:

$ c3c compile holamundo.c3 -o holamundo

Ejecutamos:

$ holamundo.exe

Tipos de datos y estructuras de control básicas

Ejemplo 1. Crear un programa que muestre los tipos de datos y estructuras de control en ambos lenguajes. Para el caso de Beef usaremos su IDE. C3 será compilado y ejecutado desde terminal

Beef:

Program.bf

using System;

namespace HelloWorld;

class Program
{
    static void Main()
    {
        Console.WriteLine("\t [ Fundamentos de Beef ]");
		TestA();
		TestB();
    }

	static void TestA(){
		Console.WriteLine("\t [ Tipos de variables en Beef ]");
		int entero = 42;
		float flotante = 3.14f;
		double doble = 2.71828;
		bool booleano = true;
		char8 caracter = 'A';
		String texto = "Hola, mundo";

		Console.WriteLine($"Entero: {entero}");
		Console.WriteLine($"Flotante: {flotante}");
		Console.WriteLine($"Doble: {doble}");
		Console.WriteLine($"Booleano: {booleano}");
		Console.WriteLine($"Caracter: {caracter}");
		Console.WriteLine($"Texto: {texto}");

	}


	static void TestB(){
		Console.WriteLine("\t [ Estructuras de control en Beef ]");
		bool numeroV =  23 > 20;
		if(numeroV){
			Console.WriteLine("Verdadero: 23 > 20");
			numeroV = 300 < 100;
		}

		if(numeroV){
			Console.WriteLine("Verdadero: 300 < 10");
		}else{
			Console.WriteLine("Falso: 300 < 100");
		}

		int x = 3;
		if (x < 0)
		    Console.WriteLine("x es negativo");
		else if (x == 0)
		    Console.WriteLine("x es cero");
		else
		    Console.WriteLine("x es positivo");

		switch (x)
		{
		    case 1:
		        Console.WriteLine("x es uno");
		        break;
		    case 10:
		        Console.WriteLine("x es diez");
		        break;
		    default:
			    Console.WriteLine($"x no es ni 1 ni 10 es: {x}");    
		        break;
		}


	}


}

Salida:

         [ Fundamentos de Beef ]
         [ Tipos de variables en Beef ]
Entero: 42
Flotante: 3.14
Doble: 2.71828
Booleano: True
Caracter: A
Texto: Hola, mundo
         [ Estructuras de control en Beef ]
Verdadero: 23 > 20
Falso: 300 < 100
x es positivo
x no es ni 1 ni 10 es: 3

C3:

fundamentos.c3

module fundamentos;

import std::io;

fn void main()
{
    io::printn("\t [ Fundamentos en C3 ]");
    test_a();
    test_b();
}

fn void test_b()
{
   io::printn("\t [ Estructuras de control en C3 ]");
    int x = 10;

   
    if (x > 5){
        io::printn("x es mayor que 5");
    }
    
    if (x % 2 == 0){
        io::printn("x es par");
    }else{
        io::printn("x es impar");
    }
   
    if (x < 0){
        io::printn("x es negativo");
    }else if (x == 0){
        io::printn("x es cero");
    }else{
        io::printn("x es positivo");
    }
    
    switch (x) {
        case 1:
            io::printn("x es uno");
            break;
        case 10:
            io::printn("x es diez");
            break;
        default:
            io::printf("x no es ni 1 ni 10 es: %d\n", x);
            break;
    }
}

fn void test_a()
{
    io::printn("\t [ Tipos de datos en C3 ]");

    int entero = 42;
    float flotante = 3.14f;
    double doble = 2.71828;
    bool booleano = true;
    char caracter = 'A';
    ZString texto = (ZString)"Hola, mundo";


    io::printf("Entero: %d\n", entero);
    io::printf("Flotante: %f\n", flotante);
    io::printf("Doble: %f\n", doble);
    io::printf("Booleano: %s\n", booleano ? "true" : "false");
    io::printf("Caracter: %c\n", caracter);
    io::printf("Texto: %s\n", texto);
}

Compilación:

$ c3c compile fundamentos.c3 -o fundamentos

Salida:

         [ Fundamentos en C3 ]
         [ Tipos de datos en C3 ]
Entero: 42
Flotante: 3.140000
Doble: 2.718280
Booleano: true
Caracter: A
Texto: Hola, mundo
         [ Estructuras de control en C3 ]
x es mayor que 5
x es par
x es positivo
x es diez

Ejemplo 2. Crear un programa que muestre las estructuras de control iterativas como for, while y foreach.

Beef:

Program.bf

         using System;

namespace HelloWorld;

class Program
{
    static void Main()
    {
        Console.WriteLine("\t [ Fundamentos de Beef ]");
        TestA();
    }


    static void TestA()
    {
        Console.WriteLine("\t [ Estructuras de control iterativas en Beef ]");

	    // for
	    for (int x = 0; x < 5; x++){
			Console.WriteLine($"for: i = {x}");
		}
	        

	    // while
	    int j = 0;
	    while (j < 5)
	    {
	        Console.WriteLine($"while: j = {j}");
	        j++;
	    }

	    // do-while
	    int k = 0;
	    do repeat
	    {
	        Console.WriteLine($"do-while: k = {k}");
	        k++;
	    } while (k < 5);

	    
		int[] numeros = new int[] { 1, 2, 3, 4, 5 };
		// foreach para recorrerlo
		foreach (int n in numeros){
			Console.WriteLine($"foreach: n = {n}");
		}
		 
    }
}

Salida:

         [ Fundamentos de Beef ]
         [ Estructuras de control iterativas en Beef ]
for: i = 0
for: i = 1
for: i = 2
for: i = 3
for: i = 4
while: j = 0
while: j = 1
while: j = 2
while: j = 3
while: j = 4
do-while: k = 0
do-while: k = 1
do-while: k = 2
do-while: k = 3
do-while: k = 4
foreach: n = 1
foreach: n = 2
foreach: n = 3
foreach: n = 4
foreach: n = 5

C3:

fundamentos.c3

module fundamentos;

import std::io;

fn void main()
{
    io::printn("\t [ Fundamentos en C3 ]");
    test_a();
}

fn void test_a()
{
   io::printn("\t [ Estructuras de control iterativas en C3 ]");
    
    for (int i = 0; i < 5; i++){
        io::printf("for: i = %d\n", i);
    }
    
    int j = 0;
    while (j < 5) {
        io::printf("while: j = %d\n", j);
        j++;
    }

    
    int k = 0;
    do {
        io::printf("do-while: k = %d\n", k);
        k++;
    } while (k < 5);

    

   int[5] numeros = {1, 2, 3, 4, 5};
    for (int idx = 0; idx < numeros.len; idx++){
        io::printf("array[%d] = %d\n", idx, numeros[idx]);
   }

}

Compilación:

$ c3c compile fundamentos.c3 -o fundamentos

Salida:

         [ Fundamentos en C3 ]
         [ Estructuras de control iterativas en C3 ]
for: i = 0
for: i = 1
for: i = 2
for: i = 3
for: i = 4
while: j = 0
while: j = 1
while: j = 2
while: j = 3
while: j = 4
do-while: k = 0
do-while: k = 1
do-while: k = 2
do-while: k = 3
do-while: k = 4
array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
array[4] = 5

En conclusión:

• Si buscas un lenguaje moderno con tooling completo y sintaxis más expresiva, Beef es la apuesta. 
•  Si prefieres una transición suave desde C, con mejoras de seguridad y ergonomía pero sin perder compatibilidad total, C3 es la opción.

Continuaremos con esta serie sobre lenguajes de programación.

Enlaces:

https://www.beeflang.org/
https://c3-lang.org/

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