API tools faq
paste
Advertisement
Guest User

instagras.cpp

a guest
Mar 22nd, 2018
93
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 35.35 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5.  
  6.  
  7.  
  8. using namespace std;
  9.  
  10. struct Foto{
  11.  
  12.     string ruta;
  13.     string tipo;
  14.     unsigned long int tamanio;
  15.  
  16. };
  17.  
  18. struct Usuario{
  19.  
  20.     string login;
  21.     string nombre;
  22.     string apellido;
  23.     string perfil_usuario;
  24.     Foto* v_fotos; // puntero a
  25.     int dim_vfotos;
  26.     int totalFotosUsuario; // Utiles v_fotos
  27.  
  28. };
  29.  
  30. struct TablaUsuarios{
  31.  
  32.     Usuario** punteroapuntero; // Puntero a vector dinámico de punteros a usuarios dinámicos
  33.     int totaltuplas; // Dimensión y útiles a la vez
  34.  
  35. };
  36.  
  37.  
  38.  
  39. // Sets y gets de TablaUsuarios:
  40.  
  41. Usuario** getPunteroaPuntero (const TablaUsuarios t) {
  42.  
  43.     return t.punteroapuntero;
  44.  
  45. }
  46.  
  47. void setPunteroaPuntero (TablaUsuarios &t,Usuario** dvUsuarios) {
  48.  
  49.     t.punteroapuntero=dvUsuarios;
  50.  
  51. }
  52.  
  53. int getTotalTuplas (const TablaUsuarios t) {
  54.  
  55.     return t.totaltuplas;
  56.  
  57. }
  58.  
  59. void setTotalTuplas (TablaUsuarios &t, int tuplasActuales) {
  60.  
  61.     t.totaltuplas=tuplasActuales;
  62.  
  63. }
  64.  
  65. // Sets y gets de Usuario:
  66.  
  67. void setLogin (TablaUsuarios &t, string nuevoLogin, int posicionUsuario) {
  68.  
  69.     t.punteroapuntero[posicionUsuario]->login=nuevoLogin;
  70.  
  71. }
  72.  
  73. string getLogin (const TablaUsuarios t, int posicionUsuario) {
  74.  
  75.     return t.punteroapuntero[posicionUsuario]->login;
  76.  
  77. }
  78.  
  79.  
  80. void setNombre (TablaUsuarios &t, string nuevoNombre,int posicionUsuario) {
  81.  
  82.     t.punteroapuntero[posicionUsuario]->nombre=nuevoNombre;
  83.  
  84. }
  85.  
  86. string getNombre (const TablaUsuarios t, int posicionUsuario) {
  87.    
  88.     return t.punteroapuntero[posicionUsuario]->nombre;
  89.  
  90. }
  91.  
  92.  
  93. void setApellido (TablaUsuarios &t, string nuevoApellido, int posicionUsuario) {
  94.  
  95.     t.punteroapuntero[posicionUsuario]->apellido=nuevoApellido;
  96.  
  97. }
  98.  
  99. string getApellido (const TablaUsuarios t, int posicionUsuario) {
  100.  
  101.     return t.punteroapuntero[posicionUsuario]->apellido;
  102.  
  103. }
  104.  
  105.  
  106. void setPerfil_usuario (TablaUsuarios &t, string nuevoPerfil_usuario, int posicionUsuario) {
  107.  
  108.     t.punteroapuntero[posicionUsuario]->perfil_usuario=nuevoPerfil_usuario;
  109.  
  110. }
  111.  
  112. string getPerfil_usuario (const TablaUsuarios t, int posicionUsuario) {
  113.  
  114.     return t.punteroapuntero[posicionUsuario]->perfil_usuario;
  115.  
  116. }
  117.  
  118.  
  119. void setV_fotos (TablaUsuarios &t, Foto* dvFotos, int posicionUsuario) {
  120.  
  121.     t.punteroapuntero[posicionUsuario]->v_fotos=dvFotos;
  122.  
  123. }
  124.  
  125. Foto* getV_fotos (const TablaUsuarios t, int posicionUsuario) {
  126.  
  127.     return t.punteroapuntero[posicionUsuario]->v_fotos;
  128.  
  129. }
  130.  
  131.  
  132. void setDim_vfotos (TablaUsuarios &t, int dimension, int posicionUsuario) {
  133.  
  134.     t.punteroapuntero[posicionUsuario]->dim_vfotos=dimension;
  135.  
  136. }
  137.  
  138. int getDim_vfotos (const TablaUsuarios t, int posicionUsuario) {
  139.  
  140.     return t.punteroapuntero[posicionUsuario]->dim_vfotos;
  141.  
  142. }
  143.  
  144.  
  145. void setTotalFotosUsuario (TablaUsuarios &t, int totalfotos, int posicionUsuario) {
  146.  
  147.     t.punteroapuntero[posicionUsuario]->totalFotosUsuario=totalfotos;
  148.  
  149. }
  150.  
  151. int getTotalFotosUsuario (const TablaUsuarios t, int posicionUsuario) {
  152.  
  153.     return t.punteroapuntero[posicionUsuario]->totalFotosUsuario;
  154.  
  155. }
  156.  
  157. // Sets y gets de Foto
  158.  
  159. void setRuta (TablaUsuarios &t,string nuevaRuta,int posicionUsuario,int posicionFoto) {
  160.  
  161.     t.punteroapuntero[posicionUsuario]->v_fotos[posicionFoto].ruta=nuevaRuta;
  162.  
  163. }
  164.  
  165. string getRuta (const TablaUsuarios t,int posicionUsuario,int posicionFoto) {
  166.  
  167.     return t.punteroapuntero[posicionUsuario]->v_fotos[posicionFoto].ruta;
  168.  
  169. }
  170.  
  171.  
  172. void setTipo (TablaUsuarios &t,string nuevoTipo,int posicionUsuario,int posicionFoto) {
  173.  
  174.     t.punteroapuntero[posicionUsuario]->v_fotos[posicionFoto].tipo=nuevoTipo;
  175.  
  176. }
  177.  
  178. string getTipo (const TablaUsuarios t,int posicionUsuario,int posicionFoto) {
  179.  
  180.     return t.punteroapuntero[posicionUsuario]->v_fotos[posicionFoto].tipo;
  181.  
  182. }
  183.  
  184.  
  185. void setTamanio (TablaUsuarios &t,unsigned long int nuevoTamanio,int posicionUsuario,int posicionFoto) {
  186.  
  187.     t.punteroapuntero[posicionUsuario]->v_fotos[posicionFoto].tamanio=nuevoTamanio;
  188.  
  189. }
  190.  
  191. unsigned long int getTamanio (const TablaUsuarios t,int posicionUsuario,int posicionFoto) {
  192.  
  193.     return t.punteroapuntero[posicionUsuario]->v_fotos[posicionFoto].tamanio;
  194.  
  195. }
  196.  
  197. // Modulo de debug
  198.  
  199. void imprimirVPunteros(TablaUsuarios t) {
  200.  
  201.     int totalTuplas=getTotalTuplas(t);
  202.  
  203.     for (int i=0;i<totalTuplas;i++) {
  204.  
  205.         cout << t.punteroapuntero[i] << endl;
  206.  
  207.     }
  208.  
  209. }
  210.  
  211. // Módulos back-end:
  212.  
  213. Usuario** resizeVectorPunteros(Usuario **v,int &util_actual,int &dim_actual,int dim_nueva){
  214.  
  215.    
  216.  
  217.     Usuario** nuevoVector = new Usuario* [dim_nueva];
  218.  
  219.     if (nuevoVector==0) {
  220.  
  221.         cerr << "No se le puede otorgar memoria, abortando la ejecución del programa" << endl;
  222.         exit(-1);
  223.  
  224.     }
  225.  
  226.     if (util_actual>dim_nueva) {
  227.  
  228.         util_actual=dim_nueva;
  229.  
  230.     }
  231.  
  232.     for (int i=0;i<util_actual;i++) {
  233.  
  234.         nuevoVector[i]=v[i];
  235.  
  236.     }
  237.  
  238.     dim_actual=dim_nueva;
  239.  
  240.     delete [] v;
  241.     v=0;
  242.  
  243.        
  244.  
  245.     return nuevoVector;
  246.  
  247.    
  248. }
  249.  
  250. void pausa() {
  251.  
  252.     char tecla;
  253.  
  254.     cout << "Introduzca cualquier tecla para continuar" << endl;
  255.     cin >> tecla;
  256.  
  257. }
  258.  
  259. Foto* crearVectorFotos () {
  260.  
  261.    
  262.     Foto* dvFotos= new Foto[5];
  263.  
  264.     if (dvFotos==0) {
  265.  
  266.         cerr << "Error. No hay memoria suficiente. Se abortará la ejecución" << endl;
  267.         exit(-1);
  268.  
  269.     }
  270.  
  271.     return dvFotos;
  272.  
  273. }
  274.  
  275. void eliminarVectorFotos (Foto* dvFotos) {
  276.  
  277.     delete [] dvFotos;
  278.     dvFotos=0;
  279.  
  280. }
  281.  
  282. Usuario* crearUsuario () {
  283.  
  284.     Usuario* dUsuario= new Usuario;
  285.  
  286.     if (dUsuario==0) {
  287.        
  288.         cerr << "Error. No hay memoria suficiente. Se abortará la ejecución" << endl;
  289.         exit(-1);
  290.  
  291.     }
  292.  
  293.     return dUsuario;
  294.  
  295. }
  296.  
  297. void eliminarUsuario (Usuario* dUsuario) {
  298.  
  299.     delete dUsuario;
  300.     dUsuario=0;
  301.  
  302. }
  303.  
  304. Usuario** crearVectorDePunterosaUsuarios () {
  305.  
  306.     Usuario** dvUsuarios = new Usuario*[1];
  307.  
  308.     if (dvUsuarios==0) {
  309.        
  310.         cerr << "Error. No hay memoria suficiente. Se abortará la ejecución" << endl;
  311.         exit(-1);
  312.  
  313.     }
  314.  
  315.     return dvUsuarios;
  316. }
  317.  
  318. void eliminarVectorDePunterosaUsuarios (Usuario** dvUsuarios) {
  319.  
  320.     delete [] dvUsuarios;
  321.     dvUsuarios=0;
  322.  
  323. }
  324.  
  325. void imprimirFoto (const TablaUsuarios t,int posUsuario,int posFoto) {
  326.  
  327.     string ruta;
  328.     string tipo;
  329.     unsigned long int tamanio=0;
  330.  
  331.     ruta=getRuta(t,posUsuario,posFoto);
  332.     tipo=getTipo(t,posUsuario,posFoto);
  333.     tamanio=getTamanio(t,posUsuario,posFoto);
  334.  
  335.     cout << "La ruta de la imagen es: " << ruta << endl;
  336.     cout << "La extensión de la imagen es: " << tipo << endl;
  337.     cout << "El tamaño de la imagen en bits es: " << tamanio << endl;
  338.     cout << "" << endl;
  339.  
  340. }
  341.  
  342. void imprimirFotosUsuario (const TablaUsuarios t,int posUsuario) {
  343.  
  344.     int util_vfotos = getTotalFotosUsuario(t,posUsuario);
  345.  
  346.     for (int i=0;i<util_vfotos;i++) {
  347.        
  348.         cout << "Foto " << i+1 << endl;
  349.         cout << "" << endl;
  350.         imprimirFoto(t,posUsuario,i);
  351.    
  352.     }
  353.  
  354. }
  355.  
  356. void imprimirUsuario (const TablaUsuarios t,int posUsuario) {
  357.  
  358.     string login;
  359.     string nombre;
  360.     string apellido;
  361.     string perfilUsuario;
  362.     int dim_vfotos=0;
  363.     int util_vfotos=0;
  364.  
  365.     login=getLogin(t,posUsuario);
  366.     nombre=getNombre(t,posUsuario);
  367.     apellido=getApellido(t,posUsuario);
  368.     perfilUsuario=getPerfil_usuario(t,posUsuario);
  369.     dim_vfotos=getDim_vfotos(t,posUsuario);
  370.     util_vfotos=getTotalFotosUsuario(t,posUsuario);
  371.    
  372.  
  373.     cout << "Login: " << login << endl;
  374.     cout << "Nombre: " << nombre << endl;
  375.     cout << "Apellido: " << apellido << endl;
  376.     cout << "Perfil de usuario: " << perfilUsuario << endl;
  377.     cout << "Dimensión actual del vector de fotos: " << dim_vfotos << endl;
  378.     cout << "Total de fotos: " << util_vfotos << endl;
  379.     cout << "" << endl;
  380.     cout << "Fotos: " << endl;
  381.     cout << "" << endl;
  382.     imprimirFotosUsuario(t,posUsuario);
  383.    
  384.  
  385. }
  386. // pre: el usuario ha sido insertado en la tabla
  387. void rellenarUsuario (TablaUsuarios &t,int posUsuario) {
  388.  
  389.     string login;
  390.     string nombre;
  391.     string apellido;
  392.     string perfilUsuario;
  393.  
  394.     Foto* v_fotos=0;
  395.     int dim_vfotos=5;
  396.     int totalFotosUsuario=0;
  397.  
  398.    
  399.     cout << "Introduzca su login" << endl;
  400.     cin >> login;
  401.     setLogin(t,login,posUsuario);
  402.  
  403.     cout << "Introduzca su nombre" << endl;
  404.     cin >> nombre;
  405.     setNombre(t,nombre,posUsuario);
  406.  
  407.     cout << "Introduzca su primer apellido" << endl;
  408.     cin >> apellido;
  409.     setApellido(t,apellido,posUsuario);
  410.  
  411.     cout << "Introduzca su perfil de usuario" << endl;
  412.     cin >> perfilUsuario;
  413.     setPerfil_usuario(t,perfilUsuario,posUsuario);
  414.    
  415.     v_fotos=crearVectorFotos();
  416.     setV_fotos(t,v_fotos,posUsuario);
  417.  
  418.     setDim_vfotos(t,dim_vfotos,posUsuario);
  419.    
  420.     setTotalFotosUsuario(t,totalFotosUsuario,posUsuario);
  421.  
  422. }
  423.  
  424. void insertarUsuarioEnTabla (TablaUsuarios &t,Usuario* direcUsuario,bool tablaYaCreada) {
  425.  
  426.     int dimActual=0;
  427.     Usuario** dActualVector=0;
  428.     Usuario** dNuevoVector=0;
  429.  
  430.     dimActual=getTotalTuplas(t);
  431.        
  432.     dActualVector=getPunteroaPuntero(t);
  433.        
  434.     dNuevoVector=resizeVectorPunteros(dActualVector,dimActual,dimActual,dimActual+1);
  435.        
  436.  
  437.     //cout << dActualVector << endl;
  438.     //cout << dNuevoVector << endl;
  439.     //cout << "La dimension actual es " << dimActual << endl;
  440.    
  441.     setPunteroaPuntero(t,dNuevoVector);
  442.        
  443.     //dActualVector=getPunteroaPuntero(t);
  444.  
  445.     //cout << dActualVector << endl;
  446.    
  447.     t.punteroapuntero[dimActual-1]=direcUsuario;
  448.     setTotalTuplas(t,dimActual);
  449. }
  450.  
  451.  
  452. // Módulo que busca un usuario por su atributo login y devuelve por referencia su posición en el vector de punteros, devuelve -1 si no existe el usuario
  453.  
  454. void buscarUsuarioPorLogin(const TablaUsuarios t,string loginBuscado,int &posicionUsuario) {
  455.  
  456.     int tuplasActuales=0;
  457.     bool encontrado=false;
  458.    
  459.  
  460.     tuplasActuales=getTotalTuplas(t); // Obtenemos la dimensión actual del vector de punteros a usuarios
  461.  
  462.    
  463.  
  464.     for (int i=0;(i<tuplasActuales)&&(encontrado==false);i++) { // Recorremos el vector de punteros para comparar el login de los usuarios actuales
  465.  
  466.         if (t.punteroapuntero[i]->login==loginBuscado) { // Si encontramos ese login dejaremos de buscar y guardaremos la posición del usuario
  467.  
  468.             encontrado=true;
  469.             posicionUsuario=i;
  470.  
  471.         }
  472.        
  473.     }
  474.  
  475.     if (encontrado==false) { // Si no se encuentra ese login en ningún usuario de la tabla después de buscar
  476.  
  477.         posicionUsuario = -1;
  478.  
  479.     }
  480.  
  481.  
  482. }
  483.  
  484. // Módulo que elimina un usuario de la tabla, debe existir ese usuario en la tabla
  485. void eliminarUsuario (TablaUsuarios &t,int posicionUsuario) {
  486.  
  487.             Foto* dvFotos=getV_fotos(t,posicionUsuario); // liberamos la memoria de su vector de fotos
  488.             delete [] dvFotos;
  489.             dvFotos=0;
  490.  
  491.             Usuario* dUsuario=t.punteroapuntero[posicionUsuario]; // liberamos la memoria con el contenido de la burbuja de ese usuario
  492.             delete dUsuario;
  493.             dUsuario=0;
  494.  
  495. }
  496.  
  497. void intercambiarPunteros (Usuario* &p1,Usuario* &p2) {
  498.  
  499.     Usuario* pAux=0;
  500.  
  501.     pAux=p1;
  502.     p1=p2;
  503.     p2=pAux;
  504.  
  505.     pAux=0;
  506.  
  507. }
  508.  
  509. // resize vFotos:
  510.  
  511. Foto* resizeVectorFotos(Foto* v, int &util_actual, int &dim_actual,  int dim_nueva){
  512.    
  513.     Foto* nuevoVector = new Foto [dim_nueva];
  514.  
  515.     if (util_actual>dim_nueva) {
  516.  
  517.         util_actual=dim_nueva;
  518.  
  519.     }
  520.  
  521.     if (dim_nueva<dim_actual) {
  522.  
  523.         for (int i=0;i<dim_nueva;i++) {
  524.  
  525.             nuevoVector[i].ruta=v[i].ruta;
  526.             nuevoVector[i].tipo=v[i].tipo;
  527.             nuevoVector[i].tamanio=v[i].tamanio;
  528.            
  529.  
  530.         }
  531.  
  532.     }
  533.  
  534.     if (dim_nueva>dim_actual)  {
  535.  
  536.         for (int i=0;i<util_actual;i++) {
  537.  
  538.             nuevoVector[i].ruta=v[i].ruta;
  539.             nuevoVector[i].tipo=v[i].tipo;
  540.             nuevoVector[i].tamanio=v[i].tamanio;
  541.            
  542.  
  543.         }
  544.     }
  545.  
  546.     dim_actual=dim_nueva;
  547.    
  548.  
  549.     delete [] v;
  550.     v=0;
  551.  
  552.     return nuevoVector;
  553. }
  554.  
  555. void asignarFoto (Foto &a,Foto &b) {
  556.  
  557.     a.ruta=b.ruta;
  558.     a.tipo=b.tipo;
  559.     a.tamanio=b.tamanio;
  560.  
  561.  
  562. }
  563.  
  564. void intercambiarFotos (Foto &a,Foto &b) {
  565.  
  566.     Foto auxFoto;
  567.    
  568.     asignarFoto(auxFoto,a);
  569.     asignarFoto(a,b);
  570.     asignarFoto(b,auxFoto);
  571.  
  572. }
  573.  
  574.  
  575.  
  576. // Modulos front-end:
  577.  
  578.  
  579. void crearTabla (TablaUsuarios &t,bool &tablaYaCreada) {
  580.  
  581.     Usuario** direcVectorDinamico=0; // Puntero al vector de punteros a usuarios
  582.     int posUsuario=0; // Posicion del usuario en el vector de punteros
  583.     int tuplasIniciales=1; // Se reserva el vector de punteros con dim=1
  584.     int util_vFotos=0;
  585.  
  586.     //Para crear usuarios de ejemplo
  587.  
  588.     Usuario* yo=0;
  589.     Usuario* u2=0;
  590.     Usuario* u3=0;
  591.     Usuario* u4=0;
  592.     Usuario* u5=0;
  593.     Usuario* u6=0;
  594.     Usuario* u7=0;
  595.    
  596.    
  597.     string login;
  598.     Foto* v_fotos=0;
  599.     int dim_vfotos=5;
  600.  
  601.    
  602.    
  603.  
  604.    
  605.  
  606.     if (tablaYaCreada==false) { // Si no existe ya una tabla se creará una con un usuario de ejemplo dentro
  607.  
  608.         // Se crea el vector dinámico de punteros y se guarda su dirección de memoria en el miembro punteroapuntero de t.
  609.  
  610.         direcVectorDinamico=crearVectorDePunterosaUsuarios(); // Creamos un vector dinámico de punteros con dimensión 1 y guardamos la dirección de memoria
  611.  
  612.         setPunteroaPuntero(t,direcVectorDinamico); // Guardamos la dirección de memoria del vector de punteros en la tabla
  613.  
  614.         setTotalTuplas(t,tuplasIniciales); // Guardamos la dimensión actual del vector de punteros en la tabla
  615.  
  616.         // Usuarios de ejemplo:
  617.  
  618.         // Ejemplo 1:
  619.  
  620.         //Creamos el nuevo usuario y guardamos su posición de memoria en el puntero yo
  621.  
  622.         yo=crearUsuario();
  623.  
  624.         //Asignamos el puntero al nuevo usuario en la única posición del vector dinámico de punteros
  625.  
  626.         t.punteroapuntero[posUsuario]=yo; // Al ser el primer ejemplo no hace falta hacer un resize, por lo que no es necesario llamar a insertar usuario en tabla
  627.                                            
  628.         //Rellenamos sus datos
  629.        
  630.         setLogin(t,"@AlexxPedrosa",posUsuario);
  631.         setNombre(t,"Alejandro",posUsuario);
  632.         setApellido(t,"Pedrosa Carrión",posUsuario);
  633.         setPerfil_usuario(t,"Admin",posUsuario);
  634.  
  635.         //Creamos su vector dinámico de fotos (con dimension 5 por defecto) y lo guardamos en el miembro v_fotos de su estructura
  636.  
  637.         v_fotos=crearVectorFotos();
  638.         setV_fotos(t,v_fotos,posUsuario);
  639.  
  640.         //Guardamos la dimensión y las útiles de su vector de fotos en los miembros de su estructura
  641.  
  642.         setDim_vfotos(t,dim_vfotos,posUsuario);
  643.         setTotalFotosUsuario(t,3,posUsuario);
  644.  
  645.         setRuta(t,"/home/cristorey/Escritorio",posUsuario,0);
  646.         setTipo(t,".jpg",posUsuario,0);
  647.         setTamanio(t,1024,posUsuario,0);
  648.    
  649.         setRuta(t,"/Imagenes",posUsuario,1);
  650.         setTipo(t,".png",posUsuario,1);
  651.         setTamanio(t,1024,posUsuario,1);
  652.  
  653.         setRuta(t,"/Descargas",posUsuario,2);
  654.         setTipo(t,".svg",posUsuario,2);
  655.         setTamanio(t,1024,posUsuario,2);
  656.        
  657.         posUsuario++; // Aumentamos en uno la variable local que nos indica la posicion del puntero al usuario en el vector de punteros
  658.  
  659.         // Ejemplo 2:
  660.  
  661.  
  662.         u2=crearUsuario();
  663.         insertarUsuarioEnTabla(t,u2,tablaYaCreada); // Se redimensionará el vector de punteros a usuarios al llamar a este modulo
  664.    
  665.         setLogin(t,"@Ejemplo2",posUsuario);
  666.         setNombre(t,"Ejemplo2",posUsuario);
  667.         setApellido(t,"Ejemplo2",posUsuario);
  668.         setPerfil_usuario(t,"Usuario",posUsuario);
  669.  
  670.         v_fotos=crearVectorFotos();
  671.         setV_fotos(t,v_fotos,posUsuario);
  672.  
  673.         setDim_vfotos(t,dim_vfotos,posUsuario);
  674.         setTotalFotosUsuario(t,2,posUsuario);
  675.  
  676.         setRuta(t,"ruta1",posUsuario,0);
  677.         setTipo(t,".jpg",posUsuario,0);
  678.         setTamanio(t,1024,posUsuario,0);
  679.    
  680.         setRuta(t,"ruta2",posUsuario,1);
  681.         setTipo(t,".png",posUsuario,1);
  682.         setTamanio(t,1024,posUsuario,1);
  683.        
  684.         posUsuario++; // Aumentamos en uno la variable local que nos indica la posicion del puntero al usuario en el vector de punteros
  685.    
  686.         // Ejemplo 3:
  687.  
  688.         u3=crearUsuario();
  689.         insertarUsuarioEnTabla(t,u3,tablaYaCreada); // Se redimensionará el vector de punteros a usuarios al llamar a este modulo
  690.    
  691.         setLogin(t,"@Ejemplo3",posUsuario);
  692.         setNombre(t,"Ejemplo3",posUsuario);
  693.         setApellido(t,"Ejemplo3",posUsuario);
  694.         setPerfil_usuario(t,"Usuario",posUsuario);
  695.  
  696.         v_fotos=crearVectorFotos();
  697.         setV_fotos(t,v_fotos,posUsuario);
  698.  
  699.         setDim_vfotos(t,dim_vfotos,posUsuario);
  700.         setTotalFotosUsuario(t,1,posUsuario);
  701.  
  702.         setRuta(t,"ruta1",posUsuario,0);
  703.         setTipo(t,".jpg",posUsuario,0);
  704.         setTamanio(t,1024,posUsuario,0);
  705.        
  706.         posUsuario++; // Aumentamos en uno la variable local que nos indica la posicion del puntero al usuario en el vector de punteros
  707.  
  708.    
  709.         // EJemplo 4:
  710.  
  711.         u4=crearUsuario();
  712.         insertarUsuarioEnTabla(t,u4,tablaYaCreada); // Se redimensionará el vector de punteros a usuarios al llamar a este modulo
  713.    
  714.         setLogin(t,"@Ejemplo4",posUsuario);
  715.         setNombre(t,"Ejemplo4",posUsuario);
  716.         setApellido(t,"Ejemplo4",posUsuario);
  717.         setPerfil_usuario(t,"Usuario",posUsuario);
  718.  
  719.         v_fotos=crearVectorFotos();
  720.         setV_fotos(t,v_fotos,posUsuario);
  721.  
  722.         setDim_vfotos(t,dim_vfotos,posUsuario);
  723.         setTotalFotosUsuario(t,4,posUsuario);
  724.  
  725.         setRuta(t,"ruta1",posUsuario,0);
  726.         setTipo(t,".jpg",posUsuario,0);
  727.         setTamanio(t,1024,posUsuario,0);
  728.  
  729.         setRuta(t,"ruta2",posUsuario,1);
  730.         setTipo(t,".jpg",posUsuario,1);
  731.         setTamanio(t,1024,posUsuario,1);
  732.  
  733.         setRuta(t,"ruta3",posUsuario,2);
  734.         setTipo(t,".jpg",posUsuario,2);
  735.         setTamanio(t,1024,posUsuario,2);
  736.  
  737.         setRuta(t,"ruta4",posUsuario,3);
  738.         setTipo(t,".jpg",posUsuario,3);
  739.         setTamanio(t,1024,posUsuario,3);
  740.        
  741.         posUsuario++; // Aumentamos en uno la variable local que nos indica la posicion del puntero al usuario en el vector de punteros
  742.    
  743.  
  744.         // EJemplo 5:
  745.  
  746.         u5=crearUsuario();
  747.         insertarUsuarioEnTabla(t,u5,tablaYaCreada); // Se redimensionará el vector de punteros a usuarios al llamar a este modulo
  748.    
  749.         setLogin(t,"@Ejemplo5",posUsuario);
  750.         setNombre(t,"Ejemplo5",posUsuario);
  751.         setApellido(t,"Ejemplo5",posUsuario);
  752.         setPerfil_usuario(t,"Usuario",posUsuario);
  753.  
  754.         v_fotos=crearVectorFotos();
  755.         setV_fotos(t,v_fotos,posUsuario);
  756.  
  757.         setDim_vfotos(t,dim_vfotos,posUsuario);
  758.         setTotalFotosUsuario(t,5,posUsuario);
  759.  
  760.         setRuta(t,"ruta1",posUsuario,0);
  761.         setTipo(t,".jpg",posUsuario,0);
  762.         setTamanio(t,1024,posUsuario,0);
  763.  
  764.         setRuta(t,"ruta2",posUsuario,1);
  765.         setTipo(t,".jpg",posUsuario,1);
  766.         setTamanio(t,1024,posUsuario,1);
  767.  
  768.         setRuta(t,"ruta3",posUsuario,2);
  769.         setTipo(t,".jpg",posUsuario,2);
  770.         setTamanio(t,1024,posUsuario,2);
  771.  
  772.         setRuta(t,"ruta4",posUsuario,3);
  773.         setTipo(t,".jpg",posUsuario,3);
  774.         setTamanio(t,1024,posUsuario,3);
  775.  
  776.         setRuta(t,"ruta5",posUsuario,4);
  777.         setTipo(t,".jpg",posUsuario,4);
  778.         setTamanio(t,1024,posUsuario,4);
  779.        
  780.         posUsuario++; // Aumentamos en uno la variable local que nos indica la posicion del puntero al usuario en el vector de punteros
  781.    
  782.  
  783.         // Ejemplo 6:
  784.  
  785.         u6=crearUsuario();
  786.         insertarUsuarioEnTabla(t,u6,tablaYaCreada); // Se redimensionará el vector de punteros a usuarios al llamar a este modulo
  787.    
  788.         setLogin(t,"@Ejemplo6",posUsuario);
  789.         setNombre(t,"Ejemplo6",posUsuario);
  790.         setApellido(t,"Ejemplo6",posUsuario);
  791.         setPerfil_usuario(t,"Usuario",posUsuario);
  792.  
  793.         v_fotos=crearVectorFotos();
  794.         setV_fotos(t,v_fotos,posUsuario);
  795.  
  796.         setDim_vfotos(t,dim_vfotos,posUsuario);
  797.         setTotalFotosUsuario(t,0,posUsuario);
  798.  
  799.         posUsuario++; // Aumentamos en uno la variable local que nos indica la posición del puntero al usuario en el vector de punteros
  800.  
  801.        
  802.         // EJemplo 7:
  803.  
  804.         u7=crearUsuario();
  805.         insertarUsuarioEnTabla(t,u7,tablaYaCreada); // Se redimensionará el vector de punteros a usuarios al llamar a este modulo
  806.    
  807.         setLogin(t,"@Ejemplo7",posUsuario);
  808.         setNombre(t,"Ejemplo7",posUsuario);
  809.         setApellido(t,"Ejemplo7",posUsuario);
  810.         setPerfil_usuario(t,"Usuario",posUsuario);
  811.  
  812.         v_fotos=crearVectorFotos();
  813.         setV_fotos(t,v_fotos,posUsuario);
  814.  
  815.         setDim_vfotos(t,dim_vfotos,posUsuario);
  816.         setTotalFotosUsuario(t,5,posUsuario);
  817.  
  818.         setRuta(t,"ruta1",posUsuario,0);
  819.         setTipo(t,".jpg",posUsuario,0);
  820.         setTamanio(t,100,posUsuario,0);
  821.  
  822.         setRuta(t,"ruta2",posUsuario,1);
  823.         setTipo(t,".jpg",posUsuario,1);
  824.         setTamanio(t,200,posUsuario,1);
  825.  
  826.         setRuta(t,"ruta3",posUsuario,2);
  827.         setTipo(t,".jpg",posUsuario,2);
  828.         setTamanio(t,300,posUsuario,2);
  829.  
  830.         setRuta(t,"ruta4",posUsuario,3);
  831.         setTipo(t,".jpg",posUsuario,3);
  832.         setTamanio(t,400,posUsuario,3);
  833.  
  834.         setRuta(t,"ruta5",posUsuario,4);
  835.         setTipo(t,".jpg",posUsuario,4);
  836.         setTamanio(t,500,posUsuario,4);
  837.        
  838.         //Resize de vfotos para crear un usuario automaticamente con espacio para 6 fotos (5 por defecto):
  839.  
  840.         //Obtenemos la direccion de su vector de fotos y su dimensión y útiles actuales
  841.  
  842.         v_fotos=getV_fotos(t,posUsuario);
  843.         dim_vfotos=getDim_vfotos(t,posUsuario);
  844.         util_vFotos=getTotalFotosUsuario(t,posUsuario);
  845.  
  846.         v_fotos=resizeVectorFotos(v_fotos,util_vFotos,dim_vfotos,6); // Redimensionamos el vector con los parametros obtenidos
  847.  
  848.         //Asignamos en las estructuras de ese usuario la dirección de su nuevo vector de fotos y actualizamos la dimensión de este
  849.  
  850.         setV_fotos(t,v_fotos,posUsuario);
  851.         setDim_vfotos(t,dim_vfotos,posUsuario);
  852.        
  853.         //Rellenamos       
  854.  
  855.         setRuta(t,"ruta6",posUsuario,5);
  856.         setTipo(t,".jpg",posUsuario,5);
  857.         setTamanio(t,600,posUsuario,5);
  858.    
  859.         setTotalFotosUsuario(t,util_vFotos+1,posUsuario); // Aumentamos su total de fotos en uno
  860.  
  861.         cout << "La tabla fué creada con éxito" << endl;
  862.         cout << "" << endl;
  863.    
  864.         tablaYaCreada=true; //Actualizamos la variable que nos indica si la tabla ya existe (se devuelve por referencia)
  865.    
  866.  
  867.     } else {
  868.  
  869.         cout << "Ya existe una tabla, si quieres crear una nueva debes borrar primero la que ya existe." << endl;
  870.  
  871.     }
  872.  
  873. }
  874.            
  875. void eliminarTabla (TablaUsuarios &t,bool &tablaYaCreada) {
  876.  
  877.     if (tablaYaCreada==true) {
  878.  
  879.         int totalUsuarios=getTotalTuplas(t);
  880.  
  881.         for (int i=0;i<totalUsuarios;i++) { // Liberamos la memoria del vector dinámico de fotos de cada usuario en la tabla
  882.  
  883.             Foto* dvFotos=getV_fotos(t,i);
  884.            
  885.             delete [] dvFotos;
  886.             dvFotos=0;
  887.         }
  888.  
  889.         for (int i=0;i<totalUsuarios;i++) { // Liberamos la memoria dinámica de todos los usuarios de la tabla
  890.  
  891.             Usuario* dUsuario=t.punteroapuntero[i];
  892.             delete dUsuario;
  893.             dUsuario=0;
  894.  
  895.         }
  896.  
  897.         Usuario** dvPunteroaPuntero=getPunteroaPuntero(t); // Obtenemos la dirección del vector dinámico de punteros a usuarios
  898.        
  899.         delete dvPunteroaPuntero; // Liberamos la memoria dinámica del vector de punteros a usuarios
  900.  
  901.         cout << "La tabla fué eliminada con éxito" << endl;
  902.         cout << "" << endl;
  903.    
  904.         tablaYaCreada=false; // Postcondición: dejará de existir una tabla sobre la que operar
  905.        
  906.     } else {
  907.    
  908.         cout << "No puedes eliminar una tabla si no existe ninguna" << endl;
  909.  
  910.     }
  911.  
  912. }
  913.  
  914. void imprimirTabla (const TablaUsuarios t,bool tablaYaCreada) {
  915.    
  916.     if (tablaYaCreada==true) {
  917.  
  918.         int totalUsuarios=getTotalTuplas(t);
  919.  
  920.         for (int i=0;i<totalUsuarios;i++) {
  921.            
  922.             cout << "Usuario " << i+1 << endl;
  923.             cout << "" << endl;
  924.             imprimirUsuario(t,i);
  925.  
  926.         }
  927.  
  928.     } else {
  929.  
  930.         cout << "Debes crear una tabla antes de intentar imprimir una" << endl;
  931.         cout << "" << endl;
  932.            
  933.  
  934.     }
  935.  
  936. }
  937.  
  938.  
  939.  
  940. void insertarUsuarioFront (TablaUsuarios &t,bool tablaYaCreada) {
  941.    
  942.     Usuario* nuevoUsuario=0;
  943.     int dimActual=0;
  944.  
  945.     if (tablaYaCreada==true) {
  946.  
  947.         nuevoUsuario=crearUsuario();
  948.        
  949.         //cout << "d nuevo User : " << nuevoUsuario << endl;
  950.  
  951.         insertarUsuarioEnTabla(t,nuevoUsuario,tablaYaCreada);
  952.  
  953.         //cout << "Se ha insertado el nuevo usuario" << endl;
  954.         //cout << "direcciones en el vector" << endl;
  955.         //imprimirVPunteros(t);
  956.  
  957.         dimActual=getTotalTuplas(t);
  958.  
  959.         //cout << dimActual;
  960.  
  961.         rellenarUsuario(t,dimActual-1);
  962.  
  963.     } else {
  964.  
  965.         cerr << "No puedes insertar un usuario si no has creado una tabla antes" << endl;
  966.  
  967.     }
  968. }
  969.  
  970. void buscarUsuarioFront (const TablaUsuarios t,bool tablaYaCreada) {
  971.  
  972.     string loginQueBuscar;
  973.     int posicionUsuario=0;
  974.  
  975.     if (tablaYaCreada==true) {
  976.  
  977.         cout << "Introduce el login del usuario que deseas buscar" << endl;
  978.         cout << " " << endl;
  979.         cin >> loginQueBuscar;
  980.  
  981.         buscarUsuarioPorLogin(t,loginQueBuscar,posicionUsuario);
  982.        
  983.         if (posicionUsuario!=-1) { // Si se encontro ese login en algún usuario
  984.        
  985.             cout << " " << endl;
  986.             cout << "Se ha encontrado el usuario, se imprimirán sus datos: " << endl;
  987.             cout << " " << endl;
  988.             imprimirUsuario(t,posicionUsuario);
  989.  
  990.         } else { // Si al buscar se devolvió la posición -1
  991.    
  992.             cout << "No existe ningún usuario con ese login" << endl;
  993.        
  994.         }
  995.  
  996.     } else {
  997.  
  998.         cerr << "No puedes buscar un usuario si no has creado una tabla antes" << endl;
  999.  
  1000.     }
  1001.  
  1002.  
  1003. }
  1004.  
  1005. void eliminarUsuarioFront (TablaUsuarios &t, bool tablaYaCreada) {
  1006.  
  1007.     string loginQueBuscar;
  1008.     int posicionUsuario=0;
  1009.     int dimActual=0;
  1010.  
  1011.     Usuario** dActualVector=0;
  1012.     Usuario** dNuevoVector=0;  
  1013.  
  1014.     dimActual=getTotalTuplas(t);
  1015.  
  1016.     if (tablaYaCreada==true) {
  1017.  
  1018.         cout << "Introduce el login del usuario que deseas borrar" << endl;
  1019.         cout << " " << endl;
  1020.         cin >> loginQueBuscar;
  1021.  
  1022.         buscarUsuarioPorLogin(t,loginQueBuscar,posicionUsuario);
  1023.        
  1024.         if (posicionUsuario!=-1) { // Si se encontro ese login en algún usuario
  1025.            
  1026.             // Se eliminará el vector de fotos del usuario y su contenido en memoria dinámica
  1027.  
  1028.             cout << " " << endl;
  1029.             cout << "Se ha encontrado el usuario, se procederá a eliminar sus datos: " << endl;
  1030.             cout << " " << endl;
  1031.            
  1032.             setLogin(t,"",posicionUsuario); // Borramos los datos del usuario
  1033.             setNombre(t,"",posicionUsuario);
  1034.             setApellido(t,"",posicionUsuario);
  1035.             setPerfil_usuario(t,"",posicionUsuario);
  1036.             setDim_vfotos(t,0,posicionUsuario);
  1037.             setTotalFotosUsuario(t,0,posicionUsuario);
  1038.            
  1039.             eliminarUsuario(t,posicionUsuario); // liberamos la memoria dinámica del usuario
  1040.  
  1041.            
  1042.  
  1043.             // Se moverá su puntero a la última posicion del vector de punteros
  1044.  
  1045.             t.punteroapuntero[posicionUsuario]=t.punteroapuntero[dimActual-1];
  1046.  
  1047.             // Se redimensionará el vector de punteros
  1048.  
  1049.             dActualVector=getPunteroaPuntero(t);
  1050.             dNuevoVector=resizeVectorPunteros(dActualVector,dimActual,dimActual,dimActual-1);
  1051.  
  1052.             // Se guardará la dirección del nuevo vector en la tabla y se modificará el total de tuplas del vector de punteros en la tabla
  1053.  
  1054.             setPunteroaPuntero(t,dNuevoVector);
  1055.             setTotalTuplas(t,dimActual);
  1056.  
  1057.         } else { // Si al buscar se devolvió la posición -1
  1058.    
  1059.             cout << "No existe ningún usuario con ese login" << endl;
  1060.        
  1061.         }
  1062.  
  1063.     } else { // Si no existe la tabla
  1064.  
  1065.         cerr << "No puedes eliminar un usuario si no has creado una tabla antes" << endl;
  1066.  
  1067.     }
  1068.  
  1069. }
  1070.  
  1071. void ordenarTablaFront (TablaUsuarios &t,bool tablaYaCreada) {
  1072.  
  1073.     int fotosActuales=0;
  1074.     int fotosAnteriores=0;
  1075.     bool cambio=true;
  1076.     int dimActual=0;
  1077.  
  1078.     if (tablaYaCreada==true) {
  1079.  
  1080.         dimActual=getTotalTuplas(t);
  1081.  
  1082.         if (dimActual>1) { // No se ordenará la tabla si no existe más de un usuario en ella
  1083.  
  1084.             for (int izda=0;(izda<dimActual)&&(cambio==true);izda++) { // Se ordenara con el método de burbuja por el total de fotos
  1085.  
  1086.                 cambio=false;
  1087.  
  1088.                 for (int i=dimActual-1;i>izda;i--) {
  1089.  
  1090.                     fotosActuales=getTotalFotosUsuario(t,i);
  1091.                     fotosAnteriores=getTotalFotosUsuario(t,i-1);
  1092.  
  1093.                     if (fotosActuales>fotosAnteriores) { // Se ordenara de mayor a menor
  1094.  
  1095.                         cambio=true;
  1096.                         intercambiarPunteros(t.punteroapuntero[i-1],t.punteroapuntero[i]);
  1097.  
  1098.                     }
  1099.                 }
  1100.             }
  1101.  
  1102.             cout << "La tabla fué ordenada con éxito según el total de fotos (mayor a menor)" << endl;
  1103.  
  1104.         } else {
  1105.  
  1106.             cerr << "No puedes ordenar la tabla si no existe más de un usuario en ella" << endl;
  1107.  
  1108.         }
  1109.  
  1110.     } else {
  1111.  
  1112.         cerr << "No puedes ordenar la tabla si no has creado una tabla antes" << endl;
  1113.  
  1114.     }
  1115.  
  1116. }
  1117.  
  1118. void aniadirFotoFront (TablaUsuarios &t,bool tablaYaCreada) {
  1119.  
  1120.     int utilActual=0;
  1121.     int dim_vfActual=0;
  1122.     string ruta;
  1123.     string tipo;
  1124.     unsigned long int tamanio;
  1125.     string loginQueBuscar;
  1126.     int posicionUsuario=0;
  1127.     Foto* dvFotosActual=0;
  1128.     Foto* nueva_dvFotos=0;
  1129.  
  1130.     if (tablaYaCreada==true) {
  1131.  
  1132.         cout << "Introduce el login del usuario al que deseas añadir una foto" << endl;
  1133.         cout << " " << endl;
  1134.         cin >> loginQueBuscar;
  1135.  
  1136.         buscarUsuarioPorLogin(t,loginQueBuscar,posicionUsuario); // Se devolverá la posición en el vector de punteros del puntero a el usuario buscado
  1137.  
  1138.         if (posicionUsuario!=-1) {
  1139.  
  1140.             cout << "Se ha encontrado el usuario, se procederá a añadir una foto" << endl;
  1141.  
  1142.             utilActual=getTotalFotosUsuario(t,posicionUsuario);
  1143.             dim_vfActual=getDim_vfotos(t,posicionUsuario);
  1144.  
  1145.             if (utilActual==dim_vfActual) { // Es necesario aumentar la dimensión del vector de fotos
  1146.  
  1147.                 dvFotosActual=getV_fotos(t,posicionUsuario);
  1148.  
  1149.                 nueva_dvFotos=resizeVectorFotos(dvFotosActual,utilActual,dim_vfActual,dim_vfActual+1);
  1150.  
  1151.                 setV_fotos(t,nueva_dvFotos,posicionUsuario);
  1152.                                
  1153.  
  1154.                 cout << "Se ha redimensionado su vector de fotos" << endl;
  1155.                 //cout << "Sus útiles después de redimensionar son " << utilActual<< endl;
  1156.                 //cout << "Su dimensión después de redimensionar es " << dim_vfActual<< endl;
  1157.                 cout << "Introduzca la ruta de la imagen" << endl;
  1158.                 cin >> ruta;
  1159.                 cout << "Introduzca la extensión de la imagen" << endl;
  1160.                 cin >> tipo;
  1161.                 cout << "Introduzca el tamaño en bits de la imagen" << endl;
  1162.                 cin >> tamanio;
  1163.            
  1164.                 setRuta(t,ruta,posicionUsuario,utilActual);
  1165.                 setTipo(t,tipo,posicionUsuario,utilActual);
  1166.                 setTamanio(t,tamanio,posicionUsuario,utilActual);
  1167.  
  1168.                 setTotalFotosUsuario(t,dim_vfActual,posicionUsuario); // Cambia la dimensión y las útiles
  1169.                 setDim_vfotos(t,dim_vfActual,posicionUsuario);
  1170.                
  1171.  
  1172.             } else { // no es necesario un resize
  1173.  
  1174.                 cout << "Introduzca la ruta de la imagen" << endl;
  1175.                 cin >> ruta;
  1176.                 cout << "Introduzca la extensión de la imagen" << endl;
  1177.                 cin >> tipo;
  1178.                 cout << "Introduzca el tamaño en bits de la imagen" << endl;
  1179.                 cin >> tamanio;
  1180.            
  1181.                 setRuta(t,ruta,posicionUsuario,utilActual);
  1182.                 setTipo(t,tipo,posicionUsuario,utilActual);
  1183.                 setTamanio(t,tamanio,posicionUsuario,utilActual);
  1184.  
  1185.                 utilActual++;
  1186.                 setTotalFotosUsuario(t,utilActual,posicionUsuario); // Solo cambian las utiles de ese usuario
  1187.            
  1188.             }
  1189.  
  1190.         } else {
  1191.  
  1192.             cout << "No se ha encontrado ningún usuario con ese login" << endl;
  1193.  
  1194.         }
  1195.  
  1196.     } else {
  1197.  
  1198.         cerr << "No puedes añadir una foto a un usuario si no has creado una tabla antes" << endl;
  1199.  
  1200.     }
  1201.  
  1202. }
  1203.  
  1204. void eliminarFotoFront (TablaUsuarios &t,bool tablaYaCreada) {
  1205.  
  1206.     int utilActual=0;
  1207.     int dim_vfActual=0;
  1208.  
  1209.     int numeroFoto=0;
  1210.  
  1211.     string loginQueBuscar;
  1212.     int posicionUsuario=0;
  1213.  
  1214.     bool cambio=true;
  1215.  
  1216.     int tamanioActual=0;
  1217.     int tamanioAnterior=0;
  1218.  
  1219.     Foto foto1,foto2;
  1220.    
  1221.  
  1222.  
  1223.     if (tablaYaCreada==true) {
  1224.  
  1225.         cout << "Introduce el login del usuario del que deseas eliminar una foto" << endl;
  1226.         cout << " " << endl;
  1227.         cin >> loginQueBuscar;
  1228.  
  1229.         buscarUsuarioPorLogin(t,loginQueBuscar,posicionUsuario); // Se devolverá por referencia la posición en el vector de punteros del puntero al usuario buscado
  1230.                                                                     // Será -1 si no lo encuentra
  1231.  
  1232.         if (posicionUsuario!=-1) { // Si se encuentra un usuario con ese login
  1233.  
  1234.             utilActual=getTotalFotosUsuario(t,posicionUsuario); // Se obtendrán las útiles actuales del vector de fotos del usuario
  1235.             dim_vfActual=getDim_vfotos(t,posicionUsuario); // Se obtendrá la dimensión actual del vector de fotos del usuario
  1236.  
  1237.             if (utilActual>0) { // Si el usuario tiene alguna foto
  1238.  
  1239.                 cout << "Se ha encontrado el usuario, Introduzca el número de la foto que desea borrar" << endl;
  1240.                 cin >> numeroFoto;
  1241.  
  1242.                 if ((numeroFoto>0)&&(numeroFoto<=dim_vfActual)) { // Si el número de la foto es mayor que cero y menor o igual a las fotos totales del usuario
  1243.  
  1244.                     //Vacío el contenido de esa foto
  1245.  
  1246.                     setRuta(t,"",posicionUsuario,numeroFoto-1);
  1247.                     setTipo(t,"",posicionUsuario,numeroFoto-1);
  1248.                     setTamanio(t,0,posicionUsuario,numeroFoto-1);
  1249.  
  1250.                     if (utilActual>1) { // Si había más de una foto reordeno el vector de fotos por tamaño en bits con el método de burbuja
  1251.  
  1252.                         for (int izda=0;(izda<dim_vfActual)&&(cambio==true);izda++) {
  1253.  
  1254.                             cambio=false;
  1255.            
  1256.                             for (int i=dim_vfActual-1;i>izda;i--) {
  1257.  
  1258.                                 tamanioActual=getTamanio(t,posicionUsuario,i);
  1259.                                 tamanioAnterior=getTamanio(t,posicionUsuario,i-1);
  1260.  
  1261.                                 if (tamanioActual>tamanioAnterior) { // De mayor a menor
  1262.  
  1263.                                     cambio=true;
  1264.                                    
  1265.                                     intercambiarFotos(t.punteroapuntero[posicionUsuario]->v_fotos[i-1],t.punteroapuntero[posicionUsuario]->v_fotos[i]);
  1266.                                    
  1267.                                 }
  1268.                            
  1269.                             }
  1270.                        
  1271.                         }
  1272.  
  1273.                     }
  1274.  
  1275.                    
  1276.    
  1277.                     // Disminuyo en uno las útiles de su vector de fotos
  1278.  
  1279.                     setTotalFotosUsuario(t,utilActual-1,posicionUsuario);                  
  1280.  
  1281.                 } else {
  1282.  
  1283.                     cout << "No existe esa foto en el usuario" << endl;
  1284.  
  1285.                 }
  1286.  
  1287.             } else {
  1288.  
  1289.                 cout << "No puedes borrar una foto de un usuario si no tiene ninguna foto" << endl;
  1290.  
  1291.             }
  1292.            
  1293.         } else {
  1294.  
  1295.             cout << "No se ha encontrado ningún usuario con ese login" << endl;
  1296.  
  1297.         }
  1298.  
  1299.     } else {
  1300.  
  1301.         cerr << "No puedes eliminar una foto de un usuario si no has creado una tabla antes" << endl;
  1302.  
  1303.     }
  1304.  
  1305. }
  1306.  
  1307. void imprimirFotosUsuarioFront (const TablaUsuarios t,bool tablaYaCreada) {
  1308.  
  1309.     string loginQueBuscar;
  1310.     int posicionUsuario=0;
  1311.  
  1312.     if (tablaYaCreada==true) {
  1313.  
  1314.         cout << "Introduce el login del usuario del que deseas imprimir las fotos" << endl;
  1315.         cout << " " << endl;
  1316.         cin >> loginQueBuscar;
  1317.  
  1318.         buscarUsuarioPorLogin(t,loginQueBuscar,posicionUsuario); // Se devolverá la posición en el vector de punteros del puntero a el usuario buscado
  1319.  
  1320.         if (posicionUsuario!=-1) {
  1321.  
  1322.             cout << "Se ha encontrado el usuario, se procederá a imprimir sus fotos" << endl; 
  1323.  
  1324.             imprimirFotosUsuario (t,posicionUsuario);
  1325.    
  1326.         } else {
  1327.  
  1328.             cerr << "No se ha encontrado ningún usuario con ese login" << endl;
  1329.  
  1330.         }
  1331.  
  1332.     } else {
  1333.  
  1334.         cerr << "No puedes imprimir las fotos de un usuario si no existe ninguna tabla de usuarios" << endl;
  1335.    
  1336.     }
  1337.  
  1338. }
  1339.  
  1340. void imprimirMenu() {
  1341.  
  1342.     cout << "Elige una opcion:" << endl << "" << endl << "1º Crear tabla de usuarios" << endl << "2º Eliminar tabla de usuarios" << endl << "3º Imprimir tabla de usuarios" << endl << "4º Insertar usuario en tabla de usuarios" << endl << "5º Eliminar usuario en tabla de usuarios" << endl << "6º Buscar usuario por login" << endl << "7º Ordenar tabla por total de fotos o por login" << endl << "8º Añadir fotografia a un usuario" << endl << "9º Eliminar fotografia de un usuario" << endl << "10º Imprimir fotografias de un usuario" << endl << "11º Salir" << endl << "" << endl;
  1343.  
  1344. }
  1345.  
  1346.  
  1347.  
  1348. void menu () {
  1349.  
  1350.     bool tablaYaExiste=false; // Variable que nos indicará en cada momento si ya existe una tabla de usuarios
  1351.  
  1352.     unsigned long int opcion=0; // Declaro la variable que guardará el valor de la opción
  1353.  
  1354.     TablaUsuarios t; // Declaro una tabla y vacio el contenido de su puntero al vector dinámico y su total de tuplas (basura)
  1355.  
  1356.     t.punteroapuntero=0;
  1357.     t.totaltuplas=0;
  1358.  
  1359.    
  1360.  
  1361.     do {
  1362.  
  1363.        
  1364.  
  1365.         // Se volverá al menú después de ejecutar una opción siempre y cuando la opción no fuese salir
  1366.        
  1367.         if (opcion != 11) {  
  1368.  
  1369.             if (opcion > 11 || opcion < 0) { // Se mostrará este mensaje de error si la opción era un número incorrecto
  1370.                
  1371.                 cout << "" << endl;
  1372.                 cout << "Debes elegir una de las opciones del menú" << endl;
  1373.                 cout << "" << endl;
  1374.  
  1375.             }          
  1376.  
  1377.             imprimirMenu();
  1378.             cin >> opcion;
  1379.            
  1380.             if (!cin) { // Se mostrara este mensaje de error si la opción no era un número, y se limpiará e ignorará el buffer de entrada
  1381.  
  1382.                 cin.clear();
  1383.                 cin.ignore(100,'\n');
  1384.  
  1385.                 cout << "" << endl;
  1386.                 cerr << "Debes elegir una de las opciones del menú" << endl;
  1387.                 cout << "" << endl;
  1388.  
  1389.             }          
  1390.  
  1391.         }
  1392.  
  1393.         // Opción 11: Se comprobará si la tabla se ha borrado antes de acabar el programa, no se podra salir del programa
  1394.                         //sin haber eliminado antes la tabla de usuarios.
  1395.  
  1396.         if (opcion == 11) { // Si la opción es salir.
  1397.  
  1398.             if (tablaYaExiste==true) { // y la tabla ya existe.
  1399.  
  1400.                 do { // Se mostrará el mensaje de advertencia y se mostrará de nuevo el menú para elegir una opción.
  1401.  
  1402.                     cerr << "No puedes salir del programa sin eliminar la tabla de usuarios" << endl;
  1403.                     pausa();
  1404.        
  1405.                     imprimirMenu();
  1406.  
  1407.                     cin >> opcion;
  1408.  
  1409.                     if (!cin) { // Se mostrara este mensaje de error si la opción no era un número, y se limpiará e ignorará el buffer de entrada
  1410.                         cin.clear();
  1411.                         cin.ignore(100,'\n');
  1412.                         cout << "" << endl;
  1413.                         cerr << "Debes elegir una de las opciones del menú" << endl;
  1414.                     }
  1415.  
  1416.                     cout << "" << endl;
  1417.  
  1418.                 } while (opcion==11); // Esto ocurrirá siempre que la opción sea acabar el programa cuando ya existe una tabla.
  1419.  
  1420.             } else { // En caso contrario se dejará al usuario acabar la ejecución del programa .
  1421.  
  1422.                 cout << "Ha decidido acabar con la ejecución del programa" << endl << "" <<  endl;
  1423.  
  1424.             }
  1425.  
  1426.         }
  1427.        
  1428.         // Opción 1: Se creará la tabla de usuarios, no será posible crear una tabla si ya existe una
  1429.        
  1430.         if (opcion == 1) {
  1431.  
  1432.             crearTabla(t,tablaYaExiste);
  1433.             pausa();
  1434.        
  1435.         }
  1436.  
  1437.        
  1438.         // Opción 2: Se eliminará la tabla de usuarios, no será posible eliminar una tabla si no existe ninguna
  1439.        
  1440.         if (opcion == 2) {
  1441.  
  1442.             eliminarTabla(t,tablaYaExiste);
  1443.             pausa();
  1444.        
  1445.         }
  1446.  
  1447.  
  1448.         // Opción 3: Se imprimirá la tabla de usuarios, no será posible imprimir una tabla si no existe ninguna
  1449.        
  1450.         if (opcion == 3) {
  1451.  
  1452.             imprimirTabla(t,tablaYaExiste);
  1453.             pausa();
  1454.        
  1455.         }
  1456.  
  1457.         if (opcion == 4) {
  1458.  
  1459.             insertarUsuarioFront(t,tablaYaExiste);
  1460.             pausa();
  1461.  
  1462.         }
  1463.  
  1464.         if (opcion == 5) {
  1465.  
  1466.             eliminarUsuarioFront(t,tablaYaExiste);
  1467.             pausa();
  1468.  
  1469.         }
  1470.  
  1471.         if (opcion == 6) {
  1472.  
  1473.             buscarUsuarioFront(t,tablaYaExiste);
  1474.             pausa();
  1475.  
  1476.         }
  1477.  
  1478.         if (opcion == 7) {
  1479.  
  1480.             ordenarTablaFront(t,tablaYaExiste);
  1481.             pausa();
  1482.  
  1483.         }
  1484.  
  1485.         if (opcion == 8) {
  1486.  
  1487.             aniadirFotoFront(t,tablaYaExiste);
  1488.             pausa();
  1489.  
  1490.         }
  1491.  
  1492.  
  1493.         if (opcion == 9) {
  1494.  
  1495.             eliminarFotoFront(t,tablaYaExiste);
  1496.             pausa();
  1497.  
  1498.         }
  1499.  
  1500.         if (opcion == 10) {
  1501.  
  1502.             imprimirFotosUsuarioFront(t,tablaYaExiste);
  1503.             pausa();           
  1504.  
  1505.         }
  1506.  
  1507.  
  1508.        
  1509.  
  1510.     } while (opcion!=11); // Mientras que la opcion no sea 11 no se saldrá del bucle, si la tabla aún está creada la opción no puede ser 11.
  1511.    
  1512. }
  1513.  
  1514. int main () {
  1515.  
  1516.     menu();
  1517.  
  1518. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!