(actualizacion. ya solucione el problema, simplemente utilice claude en vez de chatgpt)
un poco de contexto. tengo un amigo que estudia animación porque… es masoquista, no puedo describirlo de otra forma, y bueno, para que el hombre tenga por fin un respiro, decidi crear un programa para crear horarios, y asi nunca mas pueda poner excusas del tipo, se me olvido, o esto ahora no me encaja, o cosas asi, asi que dije, le voy a crear un programa para hacer horarios, y asi no me pondra mas excusas. bueno, digamos que mis conocimientos en programación son un poco escasos y bien, decidi hacer esto con chatgpt. tengo una minima nocion de como hacer esto, pero tampoco mucha y personalmente creo que el resultado de momento no es del todo malo. digamos que estoy en una etapa de prealfa o alfa (honestamente no se como funciona esto de las versiones) y bueno, queria ver si alguien podria darme una pequeña ayuda o alguna idea de que estoy haciendo mal
la sintaxis es un poco rara ya que en un momento con 100% se sobriedad y 100% de racismo hacia grigos decidi hacer la sintaxis del programa completamente en español pero con una libreria que tradujera todo a algo que entendiera la maquina, asi que entiendo confunsiones y los palos en los comentarios (por cierto el archivo de sintaxis ahorita esta incompleto, ya que ahorita queria ver si funcionaba y luego le pondria una sintaxis propias)
otras 3 aclaraciones antes de empezar. primero tengo algunos archivos definiendo metas de lo que quiero conseguir para que mi organizacion no se nefasta, y si quieren los puedo compartir para que se hagan una idea de mis objetivos, ahorita no los he incluido porque me parecia demaciado largo el texto, asi que por acortar lo omiti
segundo, creo que por el lugar que estamos, se entenderia un poco el hecho que esto lo quiero hacer de codigo abierto, o al menos si tengo un programa minimamente decente, no me molestaria simplemente regalar el codigo para quien lo quisiera, poniendo en algun tipo de licencia de codigo abierto o software libre, yo solo quiero que se pueda ejecutar donde sea y ya, pero bueno, digamos que el sobre el tema de licencias no tengo ni la mas minima idea
y por ultimo, el error que tengo creo que esta relacionado con el archivo de rutina, no se si el .cpp o .h, lo que pasa es que no puedo guardar los archivos con las rutinas, siempre me exporta un archivo en blanco, y cuando intento cargar un archivo echo aparte siguiendo la logica que quise seguir pues… tampoco funciona
y ya esto lo ultimo y los dejo con el codigo, si quieren puedo darles el codigo puro en c++ para que tengan una mejor idea de que intente hacer, la traduccion de la sintaxis la hice manualmente asi que todavia tengo los archivos con la sintaxis que cualquier otro ser humano utilizaria:
// main.cpp
#include <map>
#include "sintaxis_es.h"
#include "horario.h"
#include "evento.h"
#include "rutina.h"
// Muestra el menú de opciones al usuario
nulo MostrarMenu() {
imp "=== Gestión de Horarios ===\n"
<< "1. Agregar evento\n"
<< "2. Eliminar evento\n"
<< "3. Mostrar eventos de un día\n"
<< "4. Guardar rutina\n"
<< "5. Cargar rutina\n"
<< "6. Cambiar formato de hora (12/24 horas)\n"
<< "7. Salir\n"
<< "Seleccione una opción: ";
}
// Función auxiliar para elegir un día de la semana
txt seleccionarDia() {
std::map<num, txt> dias = {
{1, "Lunes"},
{2, "Martes"},
{3, "Miércoles"},
{4, "Jueves"},
{5, "Viernes"},
{6, "Sábado"},
{7, "Domingo"} //Dia del señor XD
};
num opcion;
imp "Seleccione el día:\n";
cada (const fn& [indice, dia] : dias) {
imp indice << ". " << dia << '\n';
}
imp "Ingrese el número del día: ";
leer >> opcion;
si (dias.encontrar(opcion) !=dias.end()) {
dev dias[opcion];
} sino {
imp "Opción no válida. Seleccionando Lunes por defecto.\n";
dev "Lunes"; //Valor predeterminado
}
}
nucleo() {
Horario horario; // Instancia de Horario para gestionar los eventos
Rutina rutina;
bol formato24Horas = cierto; // Inicialmente en formato de 24 horas
num opcion; // Variable para almacenar la opción seleccionada por el usuario
hacer {
MostrarMenu();
leer >> opcion;
leer.ignore(); // Limpiar el buffer de entrada
si (opcion == 1) { // Agregar un evento
txt nombre, dia;
num horaInicio, minutoInicio, horaFin, minutoFin;
dia = seleccionarDia();
imp "Ingrese el nombre del evento: ";
leer.ignore(); // Limpiar el buffer antes de getline
std::getline(leer, nombre);
imp "Ingrese la hora de inicio (0-23): ";
leer >> horaInicio;
imp "Ingrese el minuto de inicio (0-59): ";
leer >> minutoInicio;
imp "Ingrese la hora de finalización (0-23): ";
leer >> horaFin;
imp "Ingrese el minuto de finalización (0-59): ";
leer >> minutoFin;
// Crea el evento usando todos los parámetros requeridos
Evento evento(nombre, horaInicio, minutoInicio, horaFin, minutoFin);
// Llama a agregarEvento con el día especificado
si (horario.agregarEvento(evento, dia)) {
imp "Evento agregado exitosamente.\n";
} sino {
imp "No se pudo agregar el evento debido a un conflicto.\n";
}
} sino si (opcion == 2) { // Eliminar un evento
txt nombre, dia;
dia = seleccionarDia();
imp "Ingrese el nombre del evento a eliminar: ";
leer.ignore(); // Limpiar el buffer antes de getline
std::getline(leer, nombre);
// Llama a eliminarEvento con el nombre y día especificados
si (horario.eliminarEvento(nombre, dia)) {
imp "Evento eliminado exitosamente.\n";
} sino {
imp "No se encontró el evento a eliminar.\n";
}
} sino si (opcion == 3) { // Mostrar eventos
txt dia = seleccionarDia();
// Llama a mostrarEventos con el día y formato especificados
horario.mostrarEventos(dia, formato24Horas);
} sino si (opcion == 4){
txt archivo;
imp "Ingrese el nombre del archivo para guardar la rutina: ";
std::getline(leer, archivo);
archivo += ".hrt"; //Extensión personalizada (hora de rutina)
si (rutina.guardarEnArchivo(archivo)) {
imp "Rutina guardada en " << archivo << " exitosamente.\n";
} sino {
imp "Error al guardar la rutina.\n";
}
} sino si (opcion == 5){
txt archivo;
imp "Ingrese el nombre del archivo para cargar la rutina: ";
std::getline(leer, archivo);
archivo += ".hrt"; // Asegurar la extensión personalizada
si (rutina.cargarDesdeArchivo(archivo)) {
imp "Rutina cargada desde " << archivo << " exitosamente.\n";
} sino {
imp "Error al cargar la rutina.\n";
}
} sino si (opcion == 6) {
formato24Horas = !formato24Horas; // Alterna el formato de 12 a 24 horas o viceversa
imp "Formato de hora cambiado a " << (formato24Horas ? "24 horas.\n" : "12 horas.\n");
} sino si (opcion == 7) {
imp "Saliendo del programa...\n";
} sino {
imp "Opción no válida. Intente de nuevo.\n";
}
} mientras (opcion != 7); // Termina cuando la opción es 4 (salir)
dev 0; // Finaliza el programa con éxito
}
// rutina.cpp
#include "rutina.h"
#include "sintaxis_es.h"
#include <fstream>
#include <sstream>
#include <iomanip>
#include <regex>
// Cargar eventos desde un archivo personalizado con extensión .hrt
bol Rutina::cargarDesdeArchivo(const txt& rutinaArchivo) {
std::ifstream archivo(rutinaArchivo);
si (!archivo) {
adv "Error: No se pudo abrir el archivo" << rutinaArchivo << " para lectura.\n";
dev falso;
}
txt linea, diaActual;
std::regex formatoEvento(R"(Evento:\s*(.+?),\s*Hora inicio:\s*(\d{2}):(\d{2}),\s*Hora fin:\s*(\d{2}):(\d{2}))");
mientras (getline(archivo, linea)) {
// Procesa la línea de evento en el contexto del día actual
std::smatch match;
si (std::regex_match(linea, match, formatoEvento)) {
// Extrae los datos del evento si coincide con el formato esperado
txt nombre = match[1];
num horaInicio = std::stoi(match[2]);
num minutoInicio = std::stoi(match[3]);
num horaFin = std::stoi(match[4]);
num minutoFin = std::stoi(match[5]);
Evento evento(nombre, horaInicio, minutoInicio, horaFin, minutoFin);
eventosDiarios[diaActual].agregar(evento);
} sino {
adv "Error: Formato de evento inválido en la línea: " << linea << '\n';
}
}
archivo.close();
dev cierto;
}
// Guarda los eventos actuales en un archivo personalizado con extensión .hrt
bol Rutina:: guardarEnArchivo(const txt& rutinaArchivo) const {
std::ofstream archivo(rutinaArchivo);
si (!archivo) {
adv "Error: No se pudo abrir el archivo " << rutinaArchivo << " para escritura.\n";
dev falso;
}
// Escribe cada día y sus eventos
cada (const fn& [dia, eventos] : eventosDiarios) {
archivo << "[" << dia << "]\n"; //Marca el inicio de un día
cada (const fn& evento : eventos) {
archivo << "Evento: " << evento.obtenerNombre()
<< ", Hora inicio: " << std::setw(2) << std::setfill('0') << evento.obtenerHoraInicio()
<< ":" << std::setw(2) << std::setfill('0') << evento.obtenerMinutoInicio()
<< ", Hora fin: " << std::setw(2) << std::setfill('0') << evento.obtenerHoraFin()
<< ":" << std::setw(2) << std::setfill('0') << evento.obtenerMinutoFin() << '\n';
}
}
archivo.close();
dev cierto;
}
// Funcion privada para parsear la línea de evento en el archivo de rutina (con regex para validar formato)
bol Rutina::parsearLinea(const txt& linea, const txt& dia) {
// Esta función no se utiliza directamente, ya que el proceso de carga maneja el parseo con regex.
dev falso;
}
// evento.cpp
#include "evento.h"
#include "sintaxis_es.h"
#include <iomanip>
#include <sstream>
// Constructor de la clase Evento: inicializa el evento con su nombre, hora y minuto de inicio y fin
Evento::Evento(const txt& nombre, num horaInicio, num minutoInicio, num horaFin, num minutoFin)
: nombre(nombre), horaInicio(horaInicio), minutoInicio(minutoInicio), horaFin(horaFin), minutoFin(minutoFin) {}
// Métodos para obtener los atributos individuales del evento
txt Evento::obtenerNombre() const { dev nombre; }
num Evento::obtenerHoraInicio() const { dev horaInicio; }
num Evento::obtenerMinutoInicio() const { dev minutoInicio; }
num Evento::obtenerHoraFin() const { dev horaFin; }
num Evento::obtenerMinutoFin() const { dev minutoFin; }
// Método para obtener la hora de inicio en formato de 12 o 24 horas
txt Evento::obtenerHoraInicioFormato(bol formato24Horas) const {
dev formatoHora(horaInicio, minutoInicio, formato24Horas);
}
// Método para obtener la hora de fin en formato de 12 o 24 horas
txt Evento::obtenerHoraFinFormato(bol formato24Horas) const {
dev formatoHora(horaFin, minutoFin, formato24Horas);
}
// Método privado para formatear la hora y minutos en formato de 12 o 24 horas
txt Evento::formatoHora(num hora, num minuto, bol formato24Horas) const {
std::ostringstream oss;
si (formato24Horas) {
oss << std::setw(2) << std::setfill('0') << hora << ":"
<< std::setw(2) << std::setfill('0') << minuto;
} sino {
num horas12 = hora % 12 == 0 ? 12 : hora % 12;
txt periodo = hora < 12 ? "AM" : "PM";
oss << std::setw(2) << std::setfill('0') << horas12 << ":"
<< std::setw(2) << std::setfill('0') << minuto << " " << periodo;
}
dev oss.str();
}
// horario.cpp
#include "sintaxis_es.h"
#include "horario.h"
#include <fstream>
// Agrega un evento al horario en el día especificado, si no hay conflicto de horarios
bol Horario::agregarEvento(const Evento& evento, const txt& dia) {
si (!hayConflicto(evento, dia)) {
eventosPorDia[dia].agregar(evento); // Usa la macro "agregar" para añadir el evento
dev cierto; // Indica que el evento fue agregado exitosamente
}
imp "Conflicto de horario detectado. Evento no agregado.\n";
dev falso; // Indica que no se pudo agregar el evento debido a un conflicto
}
// Elimina un evento del horario dado su nombre y día especificado
bol Horario::eliminarEvento(const txt& nombreEvento, const txt& dia) {
fn& eventos = eventosPorDia[dia];
cada (fn esto = eventos.begin(); esto != eventos.end(); ++esto) {
si (esto->obtenerNombre() == nombreEvento) {
eventos.eliminar(esto); // Usa la macro "eliminar" para borrar el evento
dev cierto; // Indica que el evento fue eliminado
}
}
imp "Evento no encontrado.\n";
dev falso; // Indica que el evento no se encontró en el día especificado
}
// Muestra todos los eventos de un día en formato 12 o 24 horas
nulo Horario::mostrarEventos(const txt& dia, bol formato24Horas) const {
si (eventosPorDia.encontrar(dia) != eventosPorDia.end()) {
cada (const fn& evento : eventosPorDia.at(dia)) {
imp "Evento: " << evento.obtenerNombre()
<< ", Hora de inicio: " << evento.obtenerHoraInicioFormato(formato24Horas)
<< ", Hora de fin: " << evento.obtenerHoraFinFormato(formato24Horas) << '\n';
}
} sino {
imp "No hay eventos para el día " << dia << ".\n";
}
}
// Verifica si un nuevo evento tiene un conflicto de horario en el día especificado
bol Horario::hayConflicto(const Evento& nuevoEvento, const txt& dia) const {
si (eventosPorDia.encontrar(dia) != eventosPorDia.end()) {
cada (const fn& evento : eventosPorDia.at(dia)) {
// Convierte las horas y minutos de inicio y fin a minutos para facilitar la comparación
num inicio1 = evento.obtenerHoraInicio() * 60 + evento.obtenerMinutoInicio();
num fin1 = evento.obtenerHoraFin() * 60 + evento.obtenerMinutoFin();
num inicio2 = nuevoEvento.obtenerHoraInicio() * 60 + nuevoEvento.obtenerMinutoInicio();
num fin2 = nuevoEvento.obtenerHoraFin() * 60 + nuevoEvento.obtenerMinutoFin();
// Comprueba si los horarios de los eventos se superponen
si ((inicio1 < fin2) && (inicio2 < fin1)) {
dev cierto; // Conflicto detectado
}
}
}
dev falso; // No hay conflicto de horario
}
// rutina.h
#ifndef RUTINA_H
#define RUTINA_H
#include <map>
#include "evento.h"
#include "sintaxis_es.h"
class Rutina {
public:
bol cargarDesdeArchivo(const txt& rutaArchivo);
bol guardarEnArchivo(const txt& rutaArchivo) const;
lista<Evento> obtenerEventos(const txt& dia) const;
private:
std::map<txt, lista<Evento>> eventosDiarios;
bol parsearLinea(const txt& linea, const txt& dia);
};
#endif
// horario.h
#ifndef HORARIO_H
#define HORARIO_H
#include <map>
#include "evento.h"
#include "sintaxis_es.h"
// Clase que representa un horario de eventos organizados por día
class Horario {
public:
// Agrega un evento al horario en un día específico
bol agregarEvento(const Evento& evento, const txt& dia);
// Elimina un evento del horario por su nombre y día específico
bol eliminarEvento(const txt& nombreEvento, const txt& dia);
// Muestra todos los eventos de un día en formato 12 o 24 horas
nulo mostrarEventos(const txt& dia, bol formato24Horas) const;
// Guarda el horario completo en un archivo
bol guardarHorario(const txt& archivo) const;
// Carga el horario completo desde un archivo
bol cargarHorario(const txt& archivo);
private:
std::map<txt, lista<Evento>> eventosPorDia; // Mapa de listas de eventos organizados por día
// Verifica si el nuevo evento tiene un conflicto en un día específico
bol hayConflicto(const Evento& nuevoEvento, const txt& dia) const;
};
#endif // HORARIO_H
// evento.h
#ifndef EVENTO_H
#define EVENTO_H
#include "sintaxis_es.h"
// Clase que representa un evento con nombre, hora de inicio y fin
class Evento {
public:
// Constructor que inicializa un evento con su nombre, hora y minuto de inicio y fin
Evento(const txt& nombre, num horaInicio, num minutoInicio, num horaFin, num minutoFin);
// Métodos para obtener los atributos básicos del evento
txt obtenerNombre() const; // Retorna el nombre del evento
num obtenerHoraInicio() const; // Retorna la hora de inicio del evento (horas)
num obtenerMinutoInicio() const; // Retorna el minuto de inicio del evento
num obtenerHoraFin() const; // Retorna la hora de finalización del evento (horas)
num obtenerMinutoFin() const; // Retorna el minuto de finalización del evento
// Formateo de horas en 12 y 24 horas
txt obtenerHoraInicioFormato(bol formato24Horas) const; // Retorna la hora de inicio en formato 12 o 24 horas
txt obtenerHoraFinFormato(bol formato24Horas) const; // Retorna la hora de fin en formato 12 o 24 horas
private:
txt nombre; // Nombre del evento
num horaInicio; // Hora de inicio del evento (horas)
num minutoInicio; // Minuto de inicio del evento
num horaFin; // Hora de fin del evento (horas)
num minutoFin; // Minuto de fin del evento
// Método privado para formatear la hora y minuto en 12 o 24 horas
txt formatoHora(num hora, num minuto, bol formato24Horas) const;
};
#endif
// sintaxis_es.h
#ifndef SINTAXIS_ES_H
#define SINTAXIS_ES_H
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
#include <algorithm> // Para uso de algoritmos estándar
// --- Tipos de Datos ---
typedef int num; // Para enteros
typedef bool bol; // Para booleanos
typedef std::string txt; // Para cadenas de texto
// Plantilla de lista para soportar vectores de cualquier tipo de dato
template<typename T>
using lista = std::vector<T>; // Definición de lista genérica
// --- Constantes ---
#define cierto true // Equivalente a 'true'
#define falso false // Equivalente a 'false'
// --- Métodos de Contenedores (Equivalencias en Español) ---
#define agregar push_back // Añadir elemento a un contenedor
#define eliminar erase // Eliminar elemento de un contenedor
#define encontrar find // Encontrar un elemento en un contenedor
#define tamano size // Obtener el tamaño de un contenedor
#define vacio empty // Verificar si el contenedor está vacío
// --- Entrada y Salida ---
#define imp std::cout << // Imprimir en consola
#define adv std::cerr << // Mensajes de error o advertencia en consola
inline std::istream& leer = std::cin; // Leer entrada de datos desde el usuario, usando alias en lugar de macro
// --- Control de Flujo ---
#define si if // Condicional 'if'
#define sino else // Alternativa 'else'
#define mientras while // Bucle mientras
#define cada for // Bucle para iteraciones
#define hacer do // Bucle hacer-mientras
#define romper break // Para romper un bucle
#define continuar continue // Para continuar en el siguiente ciclo
#define nulo void // Representa el tipo 'void'
// --- Control de Flujo (Switch/Case) ---
#define segun switch // Estructura de selección múltiple
#define caso case // Cada caso dentro de 'switch'
#define defecto default // Caso por defecto en 'switch'
// --- Manejo de Funciones ---
#define fn auto // Declaración de función con tipo automático
#define dev return // Devolver valor en función
// --- Manejo de Excepciones ---
#define cap try // Bloque 'try' para manejo de excepciones
#define excep catch // Bloque 'catch' para capturar excepciones
// --- Punto de Entrada del Programa ---
#define nucleo int main // Punto de entrada principal del programa
#endif // SINTAXIS_ES_H
