Tema: Como declarar un tipo
Ver Mensaje Individual
  #6 (permalink)  
Antiguo 28/06/2016, 12:27
dehm
 
Fecha de Ingreso: septiembre-2010
Mensajes: 494
Antigüedad: 14 años, 1 mes
Puntos: 10
Respuesta: Como declarar un tipo
Bueno, estaba pensando en subir el código a github, pero precisamente quería asearlo y depurarlo un poco (o mucho) antes de hacerlo.

Voy a tratar de ponerlo partido.
Grafo.h:
Código C++: 
Ver original
  1. #ifndef GRAFO_H
  2. #define GRAFO_H
  3.  
  4. #include <stack>
  5. #include <list>
  6. #include <utility>
  7. #include "Functores.h"
  8.  
  9. class TratarArista;
  10. class TratarNodo;
  11. class TratarAristaConNiveles;
  12. class ImprimirArbol;
  13.  
  14. template <typename DATOA, typename DATON>
  15. struct arista;//declaración previa
  16.  
  17. template <typename DATON, typename DATOA>
  18. struct nodo
  19. {
  20.     DATON datonodo;
  21.     unsigned short int nPadres;
  22.     nodo<DATON,DATOA>* siguiente;
  23.     arista<DATOA,DATON>* adyacente;
  24.     //constructor
  25.     nodo (DATON N=0, unsigned short int numPadres=0, nodo<DATON,DATOA>* s=0, arista<DATOA, DATON>* a=0):datonodo(N),nPadres(numPadres),siguiente(s),adyacente(a) {}
  26.     //constructor copia
  27.     nodo (const nodo<DATON,DATOA>& n)
  28.     {
  29.         //std::cout<<"nodo Constructor copia"<<std::endl;
  30.         datonodo=n.datonodo;
  31.         nPadres=n.nPadres;
  32.         siguiente=0;
  33.         adyacente=0;
  34.     }
  35.     //destructor
  36.     ~nodo()
  37.     {
  38.         siguiente=0;
  39.         adyacente=0;
  40.         //borrar pila?
  41.         //borrar datonodo?
  42.         std::cout<<"Destructor nodo"<<std::endl;
  43.     }
  44.     //operador de asignacion
  45.     nodo& operator = (const nodo<DATON, DATOA>& n)
  46.     {
  47.         if (this!=&n)
  48.             {
  49.                 datonodo=n.datonodo;
  50.                 nPadres=n.nPadres;
  51.                 siguiente=0;
  52.                 adyacente=0;
  53.             }
  54.         return *this;
  55.     }
  56. };
  57.  
  58. template <typename DATOA, typename DATON>
  59. struct arista
  60. {
  61.     DATOA datoarista;
  62.     nodo<DATON,DATOA>* destino;
  63.     arista<DATOA,DATON>* siguiente;
  64.     arista<DATOA,DATON>* anterior;
  65.     //constructores
  66.     arista(DATOA A=0, nodo<DATON,DATOA>* d=0, arista<DATOA,DATON>* s=0, arista<DATOA,DATON>* an=0):datoarista(A),destino(d),siguiente(s), anterior(an) {}
  67.     arista (const arista<DATOA,DATON>& a)
  68.     {
  69.         datoarista=a.datoarista;
  70.         destino=0;
  71.         siguiente=0;
  72.         anterior=0;
  73.     }
  74.     //operador de asignacion
  75.     arista& operator = (const arista<DATOA, DATON>& a)
  76.     {
  77.         if (this!=&a)
  78.             {
  79.                 datoarista=a.datoarista;
  80.                 destino=0;
  81.                 siguiente=0;
  82.                 anterior=0;
  83.             }
  84.         return *this;
  85.     }
  86. };
  87.  
  88. template <typename DATON, typename DATOA>
  89. class Grafo
  90. {
  91. public:
  92.  
  93.     typedef DATON datonodo_t;
  94.     typedef DATOA datoarista_t;
  95.     typedef nodo<datonodo_t,datoarista_t>* pNodo;
  96.     typedef arista<datoarista_t,datonodo_t>* pArista;
  97.     typedef nodo<datonodo_t,datoarista_t> t_nodo;
  98.     typedef arista<datoarista_t,datonodo_t> t_arista;
  99.     //constructor
  100.     Grafo():Raiz(0),nNodos(0) {std::cout<<"Constructor grafo"<<std::endl;}
  101.     //constructor copia
  102.     Grafo (const Grafo& G);
  103.     //sobrecarga del operador =
  104.     Grafo& operator=(const Grafo& G);
  105.  
  106.     //funciones
  107.     /************auxiliares de nodos y aristas***************/
  108.     void anadirNodo (pNodo& n);
  109.     void eliminarNodo(pNodo& n);
  110.     void anadirArista (pNodo& NodoOrigen, pNodo& NodoDestino, pArista& precedente, pArista& NuevaArista);
  111.     void eliminarArista (pArista& A);
  112.     /*********insertar,eliminar,copiar elementos del grafo*******************/
  113.     void InsertarHijo(pNodo& padre, pNodo& hijo, pArista& precedente, pArista& NuevaArista);
  114.     void borrarNodos(pArista& A);
  115.     void CopiarNodo(pNodo& padre, pNodo& hijo, pArista& precedente, pArista& NuevaArista);
  116.     /******funciones para recorrer el grafo*************************/
  117.     void recorrerHijos(const pNodo& padre, TratarArista& tratamiento);
  118.     void recorrerGrafo(pNodo& inicio, TratarArista& tratamiento);
  119.     void recorrerGrafoConNiveles(pNodo& inicio, TratarAristaConNiveles& tratamiento, int n=0);
  120.     void recorrerAncestros(pNodo& n,TratarNodo& tratamiento);
  121.     void recorrerNodos(TratarNodo& tratamiento);
  122.     /**********comprobaciones necesarias****************/
  123.     bool esReferenciaCircular(pNodo& padre, pNodo& hijo);
  124.     bool existeHermano (pNodo& padre, pNodo& hijo);
  125.     bool existeNodo (const pNodo& n);
  126.     /***********otras*******************************/
  127.     void guardaAristas (pNodo& n);
  128.     void guardaAristasNivel (pNodo& n, int nivel);
  129.     pNodo posicionarseEnNodo(datonodo_t dato);
  130.     /***********consultoras*************************/
  131.     int LeeNumNodos()const {return nNodos;}
  132.     int NivelNodoPadre(pNodo& padre) const;
  133.     /****************funciones para la lista de hojas********************/
  134.     //poner aqui
  135.  
  136.  
  137.     //Destructor
  138.     ~Grafo();
  139.  
  140.     //private:
  141.     pNodo Raiz;
  142.     int nNodos;
  143.     std::stack<pArista> pila;
  144.     std::stack<std::pair<pArista,int> >pilaniveles;
  145.     std::list<pNodo>listaHojas;
  146. };
__________________
Mi calculadora en Qt