Programa en C++ con POO: Simulador de Cajero Automático (ATM)

¡Hola! Entiendo que quieres un desglose paso a paso del programa del cajero automático (ATM) que creé, junto con una explicación detallada de las funciones y métodos. Voy a estructurarlo de manera clara y secuencial para que sea fácil de seguir, especialmente si eres principiante en POO (Programación Orientada a Objetos) en C++.

El programa simula un ATM básico usando clases para encapsular la lógica (buena práctica de POO). Usaré el código que proporcioné anteriormente como base. Al final, incluyo consejos para modificarlo.

Resumen General del Programa

• Estructura: Dos clases principales (Cuenta y Cajero), funciones privadas/públicas, y un main() simple.
• Flujo: Autenticación → Menú interactivo → Procesar opciones → Salir.
• Conceptos POO clave:
  • Encapsulación: Datos privados (ej: saldo, pin) accesibles solo vía métodos públicos.
  • Constructor: Inicializa objetos con valores por defecto.
  • Métodos: Funciones dentro de clases para operaciones específicas.
• Bibliotecas: <iostream> para I/O, <iomanip> para formatear números (ej: decimales).

Ahora, vamos paso a paso por el flujo del programa, y luego explico cada función/método en detalle.

Requisitos y Preparación para tu Proyecto de Cajero Automático en C++

Antes de codificar, asegúrate de tener:

• Entorno: Visual Studio Code con extensión C++, o un compilador online como OnlineGDB.
• Bibliotecas: <iostream> para entrada/salida, <iomanip> para formateo numérico, <string> para textos.
• Conceptos previos: Clases, métodos, bucles do-while y switch.

Guarda el código en un archivo cajero.cpp. Compila con g++ cajero.cpp -o cajero y ejecuta con ./cajero. PIN inicial: 1234, saldo: $1000.00.

Estructura General del Programa: Las Clases Clave en POO

Nuestro código de cajero automático en C++ se basa en dos clases principales:

1. Clase Cuenta: Maneja el estado bancario (saldo, PIN, titular).
2. Clase Cajero: Controla la autenticación y el menú interactivo.

Esto sigue el principio de responsabilidad única en POO: cada clase hace una cosa bien. A continuación, el código completo para que lo pruebes de inmediato.

Estructura de Directorios Recomendada

Usa esta organización en una carpeta principal llamada proyecto_cajero_atm/:

proyecto_cajero_atm/
├── include/          # Cabeceras (.h): Declaraciones de clases y funciones
│   ├── Cuenta.h      # Declaración de la clase Cuenta
│   └── Cajero.h      # Declaración de la clase Cajero
├── src/              # Fuentes (.cpp): Implementaciones de clases y main
│   ├── Cuenta.cpp    # Implementación de métodos de Cuenta
│   ├── Cajero.cpp    # Implementación de métodos de Cajero
│   └── main.cpp      # Punto de entrada principal
├── build/            # Archivos generados (ignora en Git)
│   └── cajero        # Ejecutable compilado
└── Makefile          # Script para compilar fácilmente (opcional, pero útil)

Por qué esta estructura?

• Separación de preocupaciones: Headers definen "qué" (interfaces), sources definen "cómo" (lógica).
• Compilación: Usa -I include para encontrar headers.
• Ventajas POO: Fácil agregar herencia o más clases sin tocar main.
• Herramientas: Usa g++ para compilar, o IDE como Visual Studio Code con CMake.

 

Estructura General del Programa: Las Clases Clave en POO

include/Cuenta.h (Declaración de la clase Cuenta)

#ifndef CUENTA_H  // Guardia de inclusión para evitar duplicados
#define CUENTA_H

#include <string>
#include <iostream>
#include <iomanip>

class Cuenta {
private:
    double saldo;       // Saldo privado
    std::string pin;    // PIN privado
    std::string titular; // Nombre del titular

public:
    // Constructor
    Cuenta(std::string tit = "Usuario Predeterminado", double sal = 1000.00, std::string p = "1234");

    // Métodos públicos
    bool verificarPin(std::string p);
    void cambiarPin(std::string nuevoPin);
    double obtenerSaldo();
    void depositar(double monto);
    bool retirar(double monto);
    bool transferir(double monto, Cuenta& otraCuenta);
    std::string obtenerTitular();
};

#endif

 

Explicación breve: Solo declara la clase y métodos (sin cuerpos). Usa std:: explícito para evitar using namespace std;. Guardia #ifndef previene inclusiones múltiples.

src/Cuenta.cpp (Implementación de Cuenta)

#include "../include/Cuenta.h"  // Incluye su propio header

// Constructor
Cuenta::Cuenta(std::string tit, double sal, std::string p) {
    titular = tit;
    saldo = sal;
    pin = p;
}

// Implementación de métodos
bool Cuenta::verificarPin(std::string p) {
    return (pin == p);
}

void Cuenta::cambiarPin(std::string nuevoPin) {
    pin = nuevoPin;
    std::cout << "PIN cambiado exitosamente." << std::endl;
}

double Cuenta::obtenerSaldo() {
    return saldo;
}

void Cuenta::depositar(double monto) {
    if (monto > 0) {
        saldo += monto;
        std::cout << "Depósito exitoso. Nuevo saldo: $" << std::fixed << std::setprecision(2) << saldo << std::endl;
    } else {
        std::cout << "Monto inválido." << std::endl;
    }
}

bool Cuenta::retirar(double monto) {
    if (monto > 0 && monto <= saldo) {
        saldo -= monto;
        std::cout << "Retiro exitoso. Nuevo saldo: $" << std::fixed << std::setprecision(2) << saldo << std::endl;
        return true;
    } else {
        std::cout << "Saldo insuficiente o monto inválido." << std::endl;
        return false;
    }
}

bool Cuenta::transferir(double monto, Cuenta& otraCuenta) {
    if (monto > 0 && monto <= saldo) {
        saldo -= monto;
        otraCuenta.saldo += monto;  // Acceso directo para simplicidad
        std::cout << "Transferencia exitosa. Nuevo saldo: $" << std::fixed << std::setprecision(2) << saldo << std::endl;
        std::cout << "Saldo en cuenta destino: $" << std::fixed << std::setprecision(2) << otraCuenta.saldo << std::endl;
        return true;
    } else {
        std::cout << "Saldo insuficiente o monto inválido." << std::endl;
        return false;
    }
}

std::string Cuenta::obtenerTitular() {
    return titular;
}

Explicación breve: Define los cuerpos de métodos con Clase::metodo(). Incluye el header relativo (../include/) para acceder a la declaración.

include/Cajero.h (Declaración de la clase Cajero)

#ifndef CAJERO_H
#define CAJERO_H

#include "Cuenta.h"  // Incluye la clase Cuenta

class Cajero {
private:
    Cuenta cuentaPrincipal;  // Cuenta del usuario
    Cuenta cuentaDestino;    // Cuenta simulada para transferencias

public:
    // Constructor
    Cajero();

    // Métodos
    bool autenticar();
    void mostrarMenu();
    void ejecutar();
};

#endif

Explicación breve: Declara la clase, incluyendo Cuenta.h. Atributos privados como objetos de Cuenta.

src/Cajero.cpp (Implementación de Cajero)

#include "../include/Cajero.h"
#include <iostream>

// Constructor
Cajero::Cajero() : cuentaPrincipal("Juan Pérez", 1000.00, "1234"), cuentaDestino("Banco", 5000.00, "0000") {}

bool Cajero::autenticar() {
    std::string pin;
    std::cout << "Bienvenido al Cajero Automático." << std::endl;
    std::cout << "Ingrese su PIN: ";
    std::cin >> pin;
    if (cuentaPrincipal.verificarPin(pin)) {
        std::cout << "Acceso concedido. Bienvenido, " << cuentaPrincipal.obtenerTitular() << "." << std::endl;
        return true;
    } else {
        std::cout << "PIN incorrecto. Acceso denegado." << std::endl;
        return false;
    }
}

void Cajero::mostrarMenu() {
    int opcion;
    do {
        std::cout << "\n--- Menú del Cajero Automático ---" << std::endl;
        std::cout << "1. Consultar saldo" << std::endl;
        std::cout << "2. Retirar dinero" << std::endl;
        std::cout << "3. Depositar dinero" << std::endl;
        std::cout << "4. Transferir dinero" << std::endl;
        std::cout << "5. Cambiar PIN" << std::endl;
        std::cout << "6. Salir" << std::endl;
        std::cout << "Seleccione una opción: ";
        std::cin >> opcion;

        switch (opcion) {
            case 1:
                std::cout << "Saldo actual: $" << std::fixed << std::setprecision(2) << cuentaPrincipal.obtenerSaldo() << std::endl;
                break;
            case 2: {
                double monto;
                std::cout << "Monto a retirar: $";
                std::cin >> monto;
                cuentaPrincipal.retirar(monto);
                break;
            }
            case 3: {
                double monto;
                std::cout << "Monto a depositar: $";
                std::cin >> monto;
                cuentaPrincipal.depositar(monto);
                break;
            }
            case 4: {
                double monto;
                std::cout << "Monto a transferir: $";
                std::cin >> monto;
                cuentaPrincipal.transferir(monto, cuentaDestino);
                break;
            }
            case 5: {
                std::string nuevoPin;
                std::cout << "Nuevo PIN: ";
                std::cin >> nuevoPin;
                cuentaPrincipal.cambiarPin(nuevoPin);
                break;
            }
            case 6:
                std::cout << "Gracias por usar el Cajero Automático. ¡Hasta luego!" << std::endl;
                break;
            default:
                std::cout << "Opción inválida. Intente nuevamente." << std::endl;
        }
    } while (opcion != 6);
}

void Cajero::ejecutar() {
    if (autenticar()) {
        mostrarMenu();
    }
}

Explicación breve: Implementa métodos, usando objetos de Cuenta. Nota: Incluye en el header si es necesario.

src/Cajero.cpp (Implementación de Cajero)

src/main.cpp (Punto de entrada)

#include "../include/Cajero.h"  // Incluye Cajero (que incluye Cuenta)

int main() {
    Cajero atm;
    atm.ejecutar();
    return 0;
}

Explicación breve: Simple y limpio. Crea el objeto y lo ejecuta.

---

Leido 26 veces | 0 usuarios