menu practica 1

.gitignore

@@ -0,0 +1,2 @@
+*.o
+*.exe

Practica0/Makefile

@@ -0,0 +1,39 @@
+# --- Configuración general ---
+CXX = g++
+CXXFLAGS = -Wall -Wextra -std=c++17 -Iinclude
+SRC_DIR = src
+OBJ_DIR = obj
+BIN_DIR = bin
+TARGET = $(BIN_DIR)/programa
+
+# --- Archivos fuente y objeto ---
+SRCS = $(wildcard $(SRC_DIR)/*.cpp)
+OBJS = $(SRCS:$(SRC_DIR)/%.cpp=$(OBJ_DIR)/%.o)
+
+# --- Regla principal ---
+all: $(TARGET)
+
+# --- Cómo generar el ejecutable ---
+$(TARGET): $(OBJS)
+	@mkdir -p $(BIN_DIR)
+	$(CXX) $(CXXFLAGS) $(OBJS) -o $(TARGET)
+	@echo "Compilación completa. Ejecutable en $(TARGET)"
+
+# --- Cómo compilar cada .cpp a .o ---
+$(OBJ_DIR)/%.o: $(SRC_DIR)/%.cpp
+	@mkdir -p $(OBJ_DIR)
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+# --- Limpieza ---
+clean:
+	rm -rf $(OBJ_DIR)/*.o
+	@echo "Archivos objeto eliminados."
+
+mrproper: clean
+	rm -rf $(BIN_DIR)/*
+	@echo "Ejecutables eliminados."
+
+# --- Ejecución rápida ---
+run: all
+	./$(TARGET)
+

Practica0/P0.cbp

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="P0" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/P0" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Debug/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="bin/Release/P0" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-O2" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+				</Linker>
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-Wall" />
+			<Add option="-fexceptions" />
+		</Compiler>
+		<Unit filename="Practica0.cpp" />
+		<Extensions>
+			<code_completion />
+			<envvars />
+			<debugger />
+			<lib_finder disable_auto="1" />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

Practica0/Practica0.cpp

@@ -0,0 +1,502 @@
+#include <iostream> //cin, cout
+#include <conio.h> // getch
+#include <fstream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAXIMO 20
+#define M 5
+using namespace std;
+
+
+
+
+
+
+class quebrado {
+ int numerador, denominador;
+public:
+ quebrado() { numerador=0; denominador=1; }
+ quebrado(int n, int d=1);
+ int getnumerador() { return numerador; }
+ int getdenominador() {return denominador; }
+ void valor(int n, int d=1);
+ quebrado operator+(quebrado q);
+ quebrado operator-(quebrado q);
+ quebrado operator*(quebrado q);
+ quebrado operator/(quebrado q);
+ quebrado operator-();
+ int operator==(quebrado q);
+ void mostrar();
+};
+
+typedef quebrado tipoelemento ;
+
+int mcd(int a, int b) {
+ int comun,encontrado=0;
+ a=abs(a);
+ b=abs(b);
+ if (a>b)	comun=b;
+ else comun=a;
+ while (comun>1 && !encontrado)
+ {
+ if (a%comun==0 && b%comun==0)
+	  	encontrado=1;
+ else comun--;
+}
+ return(comun);
+}
+//calcula el mcm de a y b (en positivo)
+int mcm(int a, int b) {
+ int comun,encontrado;
+ if (a<0) a=-a;
+ if (b<0) b=-b;
+ if (a>b)	comun=a;
+ else comun=b;
+ encontrado=0;
+ while (!encontrado) {
+	if (comun%a==0 && comun%b==0)
+	 	encontrado=1;
+	else
+	 	comun++;
+ }
+ return(comun);
+}
+
+quebrado::quebrado(int n, int d) {
+ if (d==0) 	cout << "\nError: Quebrado no valido";
+ numerador=n; denominador=d;
+}
+
+void quebrado::valor(int n, int d) {
+ if (d==0) 	cout << "\nError: Quebrado no valido";
+ numerador=n; denominador=d;
+}
+
+void quebrado::mostrar() {
+ if (denominador>0)	cout << numerador << "/" << denominador;
+ else 	cout << -numerador << "/" << -denominador;
+}
+
+quebrado quebrado::operator/(quebrado q) {
+ quebrado division;
+ division.numerador=numerador*q.denominador;
+ division.denominador=denominador*q.numerador;
+ return division;
+}
+quebrado quebrado::operator-() {
+ quebrado aux;
+ aux.numerador=-numerador;
+ aux.denominador=denominador;
+ return aux;
+}
+
+int quebrado::operator==(quebrado q) {
+ int igual;
+ if (numerador*q.denominador==denominador*q.numerador)
+	igual=1;
+ else
+	igual=0;
+ return igual;
+}
+
+
+quebrado quebrado::operator+(quebrado q) {
+quebrado suma;
+ int comun;
+ if (denominador==q.denominador) {
+	suma.numerador= numerador + q.numerador;
+	suma.denominador = denominador;
+ }
+ else {
+	comun=mcm(denominador,q.denominador);
+	suma.denominador = comun;
+	suma.numerador=numerador*comun/denominador +	    q.numerador*comun/q.denominador;
+  }
+ return suma;
+}
+quebrado quebrado::operator-(quebrado q) {
+ quebrado resta;
+ q.numerador=-q.numerador;
+ resta=(*this)+q;
+ return(resta);
+}
+quebrado quebrado::operator*(quebrado q) {
+ quebrado producto;
+ producto.numerador=numerador*q.numerador;
+ producto.denominador=denominador*q.denominador;
+ return producto;
+}
+
+
+class complejo {
+double real, imag;
+public:
+ complejo(void) { real = 0.0; imag = 0.0; }
+ complejo(double re, double im=0.0) { real = re; imag = im;}
+ complejo(const complejo& r) { real = r.real;imag = r.imag;}
+ void SetReal(double re) { real = re; }
+ void SetImag(double im) { imag = im; }
+ double GetReal(void) {return real; }
+ double GetImag(void) {return imag; }
+ complejo operator+(int e);
+ complejo operator+(complejo c);     //por valor
+ complejo operator-(const complejo& c); //por ref
+ int operator== (complejo c);
+ complejo operator=(complejo c);
+ complejo operator*(complejo c);
+ complejo operator++(); // ++obj;
+ complejo operator++(int notused); //obj++
+ complejo operator-();
+ void mostrar();
+};
+
+
+complejo complejo::operator+ (int e) {
+ complejo suma;
+ suma.real = real + e;   suma.imag = imag;
+ return suma;
+}
+// sobrecarga de +
+complejo complejo::operator+ (complejo c) {
+ complejo suma;
+ suma.real = real + c.real;
+ suma.imag = imag + c.imag;
+ return suma;
+}
+// sobrecarga de -
+complejo complejo::operator- (const complejo &c) {
+ complejo resta;
+ resta.real = real - c.real;
+ resta.imag = imag - c.imag;
+ return resta;
+}
+// sobrecarga de ==
+int complejo::operator== (complejo c) {
+ if (real==c.real && imag==c.imag)
+  return 1;
+ else
+  return 0;
+}
+// sobrecarga de =
+complejo complejo::operator= (complejo c) {
+ real=c.real; imag=c.imag;
+ return c;
+}
+// sobrecarga de <20> unario
+complejo complejo::operator-() {
+complejo copia;
+copia.real=-real;
+copia.imag=-imag;
+return copia;
+}
+// sobrecarga de ++ (++obj)
+complejo complejo::operator++() {
+complejo copia;
+real++;
+copia.real=real;
+copia.imag=imag;
+return copia;
+}
+// sobrecarga de ++ (obj++)
+complejo complejo::operator++(int notused){
+complejo copia;
+copia.real=real;
+copia.imag=imag;
+real++;
+return copia;
+}
+//sobrecarga de *
+complejo complejo::operator*(complejo c){
+//Falta implementar
+complejo copia;
+
+
+return copia;
+}
+// mostrar complejo
+void complejo::mostrar(){
+if (imag>0)
+    cout<<real<<"+"<<imag<<"i";
+else
+    cout<<real<<imag<<"i";
+}
+
+
+
+
+
+class matriz {
+private:
+ tipoelemento celda[M][M];
+ int fila,col;
+public:
+ matriz(int f=0, int c=0);
+ int getfila() { return fila; }
+ int getcol() { return col; }
+ bool operator==(matriz m);
+ matriz operator*(matriz m);
+ matriz operator+(matriz m);
+ matriz operator-(matriz m);
+ matriz operator-();
+ void mostrar();
+ void cargar();
+ void cargar(char cad[]);
+};
+
+
+void matriz::cargar(char cad[]) {
+ int x, y;
+ FILE *fin=NULL;
+ do {
+  cout << "Filas: "; cin >> fila;
+  cout << "Columnas: "; cin >> col;
+ } while (fila>M || fila<1 || col>M || col<1);
+ cout << "Carga de una matriz " << fila << " x " << col << ":\n";
+ fin = fopen(cad, "rb");
+ if (fin != NULL) {
+  for (int i=0; i<fila; i++)
+   for (int j=0; j<col; j++) {
+            int n= rand()%80+1;
+            fseek(fin,sizeof(int)*n,SEEK_SET);
+            fread(&x,sizeof(int),1,fin);
+            fread(&y,sizeof(int),1,fin);
+            tipoelemento A(x,y);
+            celda[i][j]=A;
+            cout << "[" << i+1 << "," << j+1 << "]: ";
+            A.mostrar();
+            cout<<'\n';
+  }
+    fclose(fin);
+    fin = NULL;
+  }
+  else {
+    cout << "Error al abrir el fichero de numeros\n";
+  }
+}
+void matriz::cargar() {
+int x, y;
+ do {
+  cout << "Filas: "; cin >> fila;
+  cout << "Columnas: "; cin >> col;
+ } while (fila>M || fila<1 || col>M || col<1);
+ cout << "Carga de una matriz " << fila << " x " << col << ":\n";
+ for (int i=0; i<fila; i++) {
+  for (int j=0; j<col; j++) {
+   cout << "[" << i+1 << "," << j+1 << "]: ";
+   cin>>x>>y;
+   tipoelemento A(x,y);
+   celda[i][j]=A;
+   //A.mostrar();
+  }
+ }
+}
+
+matriz::matriz(int f, int c) {
+ fila=f;
+ col=c;
+ for (int i=0; i<fila; i++)
+  for (int j=0; j<col; j++)
+   celda[i][j]=0;
+}
+
+bool matriz::operator==(matriz m){
+    bool iguales=true;
+    if (fila==m.fila && col==m.col){
+        int i=0;
+        while(i<fila && iguales)
+        {
+            int j=0;
+            while(j<col && iguales){
+               if (!(celda[i][j]==m.celda[i][j]))
+                    iguales=false;
+               else j++;
+            }
+            i++;
+        }
+    }
+    else iguales=false;
+    return iguales;
+}
+
+matriz matriz::operator*(matriz m) {
+ int i,j,k;
+ tipoelemento prod;
+ matriz p(fila,m.col);
+ for (i=0; i< fila; i++)
+  for (j=0; j< m.col; j++) {
+   prod=0;
+   for (k=0; k< col; k++)
+    prod=prod+(celda[i][k]*m.celda[k][j]);
+   p.celda[i][j]=prod;
+  }
+ return(p);
+}
+
+matriz matriz::operator+(matriz m) {
+ int i,j;
+ matriz p(fila,col);
+ for (i=0; i< fila; i++) {
+  for (j=0; j< col; j++) {
+   p.celda[i][j]=celda[i][j]+m.celda[i][j];
+  }
+ }
+ return(p);
+}
+
+matriz matriz::operator-(matriz m) {
+ matriz p(fila,col);
+ for (int i=0; i< fila; i++) {
+  for (int j=0; j< col; j++) {
+   p.celda[i][j]=celda[i][j]-m.celda[i][j];
+  }
+ }
+ return(p);
+}
+
+matriz matriz::operator-() {
+ int i,j;
+ matriz p(fila,col);
+ for (i=0; i< fila; i++) {
+  for (j=0; j< col; j++) {
+   p.celda[i][j]=-celda[i][j];
+  }
+ }
+ return(p);
+}
+
+void matriz::mostrar() {
+ int i,j;
+ for (i=0; i<fila; i++) {
+	for (j=0; j< col; j++) {
+	 celda[i][j].mostrar();cout << "\t";
+	}
+	cout << "\n";
+ }
+}
+
+
+
+int main() {
+ matriz m[MAXIMO];
+ matriz result;
+ int n,N=0;//Numero de matrices del vector
+ int i,pos,pos2;
+ char comando[20];
+ bool salir=false;
+ system("cls");
+
+ do {
+  cout << ">";
+  fflush(stdin); gets(comando);
+  if (strcmp(comando,"cargar")==0) {
+    cout<<"Cuantas matrices quieres cargar? \n"; cin>>n;
+    if (n+N>=MAXIMO)
+     cout<<"Se excede el numero de matrices con las que operar\n";
+    else
+    {
+        N=N+n;
+        for (i=0;i<n;i++)
+                 m[i].cargar("numeros.dat");
+    }
+  }
+  else if (strcmp(comando,"listar")==0) { //listar
+   if (N==0)
+    cout << "No hay cargada ninguna matriz" << endl;
+   else
+    {
+       for (i=0;i<N;i++){
+            cout<<"\nMatriz " <<i+1<<":\n\n";
+            m[i].mostrar();
+       }
+    }
+   }
+   else if (strcmp(comando,"buscar")==0) { //buscar
+   if (N==0)
+    cout << "No hay cargada ninguna matriz" << endl;
+   else
+    {
+       result.cargar();
+
+       i=0;
+       while (i<N && !(result==m[i]))
+               i++;
+       if (result==m[i])
+              cout<<"\nLa matriz esta en la posicion "<<i<<" del vector\n";
+       else cout<<"\nNo se ha encontrado la matriz\n";
+    }
+   }
+   else if (comando[0]=='+'){
+      switch(comando[1])
+      {
+          case '+': cout<<"Posicion?:";cin>>pos;//Insertar matriz en la posicion pos
+                    if (pos>=0 && pos<=N){
+                        N++;
+                        for(i=N-1;i>=pos;i--)
+                           m[i]=m[i-1];
+                        m[pos].cargar();
+                    }
+                    else cout<<"La posicion no es valida\n";break;
+          case 0:   cout<<"Posiciones?:";cin>>pos>>pos2;//Sumar matrices en estas posiciones
+                    if (pos>=0 && pos<N && pos2>=0 && pos2<N ){
+                       if (m[pos].getfila()!=m[pos2].getfila() || m[pos].getcol()!=m[pos2].getcol())
+                           cout << "Error: Las matrices no se pueden sumar" << endl;
+                       else {
+                             result= m[pos]+ m[pos2];
+                             cout<<"Matriz resultante:\n";result.mostrar();
+                       }
+                    }
+                    else cout<<"Posiciones no validas\n";
+       }
+  }
+  else if (comando[0]=='-') {
+      switch(comando[1])
+      {
+          case '-':cout<<"Posicion?:";cin>>pos;//Eliminar matriz en la posicion pos
+                   if (pos>=0 && pos<N){
+                       for(i=pos;i<N-1;i++)
+                           m[i]=m[i+1];
+                       N--;
+                   }
+                   else cout<<"La posici<63>n no es valida\n";break;
+          case 0:  cout<<"Posiciones?:";cin>>pos>>pos2;//Restar matrices en estas posiciones
+                    if (pos>=0 && pos<N && pos2>=0 && pos2<N ){
+                       if (m[pos].getfila()!=m[pos2].getfila() || m[pos].getcol()!=m[pos2].getcol())
+                          cout << "Error: Las matrices no se pueden sumar" << endl;
+                       else {
+                             result= m[pos]-m[pos2];
+                             cout<<"Matriz resultante:\n";result.mostrar();
+                            }
+                    }
+                    else cout<<"Posiciones no validas\n";
+      }
+  }
+  else if (comando[0]=='*') {
+      cout<<"Posiciones?:";cin>>pos>>pos2;//Multiplicar matrices en estas posiciones
+      if (pos>=0 && pos<N && pos2>=0 && pos2<N){
+         if (m[pos].getcol()!=m[pos2].getfila())
+               cout << "Error: Las matrices no se pueden multiplicar" << endl;
+         else {
+               result= m[pos]*m[pos2];
+               cout<<"Matriz resultante:\n";result.mostrar();
+              }
+      }
+      else cout<<"Posiciones no validas\n";
+  }
+
+  else if (comando[0]=='?') { //Mostrar una matriz del vector
+         cout<<"Posicion?:";cin>>pos;
+         if (pos>=0 && pos<N) m[pos].mostrar();
+         else cout<<"La posicion no es valida\n";
+  }
+  else if (strcmp(comando,"salir")==0)   salir=true;
+  else
+      cout << "comando o orden incorrecta" << endl;
+
+ } while (!salir);
+
+return 0;           // Valor de retorno al S.O.
+}
+
+

Practica0/include/quebrado.h

@@ -0,0 +1,2 @@
+
+

Practica0/numeros.txt

@@ -0,0 +1,86 @@
+85
+6 7
+2 9
+9 1
+-1 5
+1 4 
+1 3
+2 3
+2 4
+9 8
+2 -3
+3 8
+1 8
+3 2
+-1 2
+9 2
+2 5
+1 2
+1 -6
+3 4
+9 7
+3 5
+-5 2
+2 3
+8 9
+5 6
+7 9
+2 5
+5 4
+-9 2
+1 2
+1 3
+3 2
+4 2
+-1 3
+1 4
+8 2
+1 5
+3 3
+2 3
+-3 5
+4 3
+9 3
+1 3
+9 3
+1 9 
+3 4
+5 8
+9 3
+4 6
+8 3
+2 5
+9 -3
+8 7
+8 3
+6 3
+5 3
+3 5
+4 3
+5 6
+-5 7
+4 3
+4 5
+1 3
+1 3
+-1 2
+9 3
+1 5
+2 3 
+-1 5
+2 5
+1 6
+2 -4
+1 4
+2 4
+2 3
+-3 7
+1 4
+5 7
+2 4
+7 4
+2 4
+-3 4
+2 4
+5 6
+3 4

Practica0/src/main.cpp

@@ -0,0 +1,14 @@
+#include <iostream>
+#include <iostream> //cin, cout
+#include <conio.h> // getch
+#include <fstream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAXIMO 20
+#define M 5
+
+using namespace std;
+
+

Practica1/main.cpp

@@ -0,0 +1,26 @@
+#include <iostream>
+#include <fstream>
+#include <conio>
+using namespace std;
+
+int main() 
+{	
+	char opcion;
+	while (opcion!=8)
+	{
+		cout<<opcion<<enl<<endl;
+		cout<<"SANCIONES APP. MENU PRINCIPAL"<<endl;
+		cout<<"===================================="<<endl;
+		cout<<"	1. Consultar cehiculo."<<endl;
+		cout<<"	2. Añadir vehiculo."<<endl;
+		cout<<"	3. Mostrar radares."<<endl;
+		cout<<"	4. Mostrar radar."<<endl;
+		cout<<"	5. Procsar radar."<<endl;
+		cout<<"	6. Mostrar fichero de sanciones."<<endl;
+		cout<<"	7. Mostrar cuantia de sancion."<<endl;
+		cout<<"	8. Salir."<<endl;
+		opcion=getch();
+	};
+	system("clear");
+	return 0;		
+};