error compilacion con Dev c++ (cerrado).

Imagen de leluza
0 puntos

hola gente! soy nueva programando y el en foro! =) algun dia tenia que empezar

estoy trabajando en Win 7 32 bits con wxDev c++, en la imagen aparece con que compila y hace debugging.

me aparece este error: 'pipe' was not declared in this scope (y lo mismo con 'fork')

me fije si estaban agregadas sus librerias, y no es ese el problema

el codigo es el siguiente, es largo porque contiene muchas clases, debido a que cuando lo quisimos compilar separado no pudimos. El problema salta al final del codigo, dentro del main donde usamos estos dos metodos

SE AGRADECE CUALQUIER APORTE =)

CODIGO

#include
#include
#include
#include /* printf, NULL */
#include /* srand, rand */
#include /* time */
#include
#include
#include
#include
#include
#include
#include
#include

#define INF 9999
#define TAM_MAX_PAG 25
#define TAM_MIN_PAG 5

#define BOLD_RED "\x1b[31;1m"
#define BOLD_BLUE "\x1b[34;1m"
#define BOLD_GREEN "\x1b[32;1m"
#define ANSI_COLOR_RED "\x1b[31m"
#define ANSI_COLOR_GREEN "\x1b[32m"
#define ANSI_COLOR_YELLOW "\x1b[33m"
#define ANSI_COLOR_BLUE "\x1b[34m"
#define ANSI_COLOR_MAGENTA "\x1b[35m"
#define ANSI_COLOR_CYAN "\x1b[36m"
#define ANSI_COLOR_BRIGHT "\x1b[1m"
#define ANSI_COLOR_RESET "\x1b[0m"

using namespace std;

template

//implementacion CLASE LISTA
class Lista {

private:
//implementacion CLASE NODO, cuya clase amiga es LISTA, y puede acceder a elemento y siguiente.
class Nodo {
friend class Lista;

private:
T elemento;
Nodo* siguiente;

public:
Nodo(T d, Nodo* n = NULL) : elemento(d), siguiente(n) {}

};
/*!End Snippet:fullNodo*/

Nodo* inicio; // Beginning of list
Nodo* final; // End of list
int cant_nodos; // Number of Nodos in list
/*!End Snippet:private*/

public:

Lista(const Lista& src); // Copy constructor
~Lista(void); // Destructor

/*!Begin Snippet:simple*/
// Default constructor
Lista(void) : inicio(NULL), final(NULL), cant_nodos(0) {}

// Returns a reference to first element
T& primer_elemento(void) {
assert (inicio != NULL && "Lista vacia"); //abortara la ejecucion dle programa mientras: 1) inicio es un puntero a nulo y 2) mensaje de lista vacia
return inicio->elemento; //&& es como una AND, ambas condiciones a la vez
}

// Returns a reference to last element
T& ultimo_elemento(void) {
assert (final != NULL); //aborta si final es un puntero nulo
return final->elemento;
}

// Returns cant_nodos of elements of list
int tamanio(void) {
return cant_nodos;
}

// Returns whether or not list contains any elements
bool es_vacia(void) {
return cant_nodos == 0;
}
/*!End Snippet:simple*/

void insertar_al_principio(T); // Insert element at beginning
void insertar_al_final(T); // Insert element at end
void quitar_primer_nodo(void); // Remove element from beginning
void quitar_ultimo_nodo(void); // Remove element from end

void mostrar(void); // Output contents of list
void imprimir(void);
void agregar(T);
T& elemento_pos(int);

void insertar_nodo_pos(T, int);
void quitar_nodo_pos(int);
void intercambiar_pos_nodos(int, int);
bool contiene(T);

};

/*!Begin Snippet:copyconstructor*/
// Copy constructor
template
Lista::Lista(const Lista& src) :
inicio(NULL), final(NULL), cant_nodos(0) {

Nodo* ptr_nodo_actual = src.inicio;
while (ptr_nodo_actual != NULL) {
this->insertar_al_final(ptr_nodo_actual->elemento);
ptr_nodo_actual = ptr_nodo_actual->siguiente;
}

}
/*!End Snippet:copyconstructor*/

/*!Begin Snippet:destructor*/
// Destructor
template
Lista::~Lista(void) {

while (! this->es_vacia()) {
this->quitar_primer_nodo();
}
}
/*!End Snippet:destructor*/

/*!Begin Snippet:pushprimer_elemento*/
// Insert an element at the beginning
template
void Lista::insertar_al_principio(T elemento) {

Nodo* nva_inicio = new Nodo(elemento, inicio);

if (this->es_vacia()) {
inicio = nva_inicio;
final = nva_inicio;
} else {
inicio = nva_inicio;
}
cant_nodos++;
}
/*!End Snippet:pushprimer_elemento*/

/*!Begin Snippet:pushultimo_elemento*/
// Insert an element at the end
template
void Lista::insertar_al_final(T elemento) {

Nodo* nvo_final = new Nodo(elemento, NULL);

if (this->es_vacia()) {
inicio = nvo_final;
} else {
final->siguiente = nvo_final;
}

final = nvo_final;
cant_nodos++;
}
/*!End Snippet:pushultimo_elemento*/

/*!Begin Snippet:popprimer_elemento*/
// Remove an element from the beginning
template
void Lista::quitar_primer_nodo(void) {

assert(inicio != NULL);

Nodo* inicio_anterior = inicio;

if (this->tamanio() == 1) {
inicio = NULL;
final = NULL;
} else {
inicio = inicio->siguiente;
}

delete inicio_anterior;
cant_nodos--;
}
/*!End Snippet:popprimer_elemento*/

/*!Begin Snippet:popultimo_elemento*/
// Remove an element from the end
template
void Lista::quitar_ultimo_nodo(void) {

assert(final != NULL);

Nodo* final_anterior = final;

if (this->tamanio() == 1) {
inicio = NULL;
final = NULL;
} else {

// Traverse the list to Nodo just before final
Nodo* ptr_nodo_actual = inicio;
while (ptr_nodo_actual->siguiente != final) {
ptr_nodo_actual = ptr_nodo_actual->siguiente;
}

// Unlink and reposition
ptr_nodo_actual->siguiente = NULL;
final = ptr_nodo_actual;
}

delete final_anterior;
cant_nodos--;
}
/*!End Snippet:popultimo_elemento*/

/*!Begin Snippet:printlist*/
// Display the contents of the list
template
void Lista::mostrar(void) {

cout << "(";

Nodo* ptr_nodo_actual = inicio;

if (ptr_nodo_actual != NULL) {

while (ptr_nodo_actual->siguiente != NULL) {
cout << ptr_nodo_actual->elemento << ", ";
ptr_nodo_actual = ptr_nodo_actual->siguiente;
}
cout << ptr_nodo_actual->elemento;
}

cout << ")" << endl;
}
template
void Lista::imprimir(void) {

cout <siguiente != NULL) {
ptr_nodo_actual->elemento.imprimir();
cout<siguiente;
}
ptr_nodo_actual->elemento.imprimir();
}

cout << "-----------------------------------------------------"<
void Lista::agregar(T elemento){
this->insertar_al_final(elemento);
}

template
T& Lista::elemento_pos(int pos){
assert (inicio != NULL && "La lista está vacía");
assert (pos<=cant_nodos-1 && "Se intenta acceder a una nodo inexistente");

Nodo* ptr_nodo_actual = inicio;
int pos_actual=0;

while (pos_actual!=pos) {
ptr_nodo_actual = ptr_nodo_actual->siguiente;
pos_actual++;
}

return ptr_nodo_actual->elemento;
}

template
void Lista::quitar_nodo_pos(int pos){

assert((pos>=0) && "Se desea quitar un nodo con posicion inválida.");
assert((pos<=cant_nodos-1) && "Se desea quitar un nodo con posicion inválida.");

if(pos==0){
this->quitar_primer_nodo();
}
else{
if(pos==(this->tamanio()-1)){
this->quitar_ultimo_nodo();
}
else{
Nodo* ptr_nodo_actual = inicio;
Nodo* ptr_nodo_anterior = NULL;
int pos_actual=0;
while (pos_actualsiguiente;
pos_actual++;
}
ptr_nodo_anterior->siguiente=ptr_nodo_actual->siguiente;
delete ptr_nodo_actual;
cant_nodos--;
}
}

}

template
void Lista::insertar_nodo_pos(T elemento, int pos){

assert(pos>=0 && "Se desea insertar un nodo con posicion inválida.");
assert(pos<=cant_nodos-1 && "Se desea insertar un nodo con posicion inválida.");

if(pos==0){
this->insertar_al_principio(elemento);
return;
}
if(pos==cant_nodos-1){
this->insertar_al_final(elemento);
return;
}
Nodo* ptr_nodo_actual = inicio;
Nodo* ptr_nodo_anterior = NULL;

int pos_actual=0;

while (pos_actual!=pos) {
ptr_nodo_anterior = ptr_nodo_actual;
ptr_nodo_actual = ptr_nodo_actual->siguiente;
pos_actual++;
}

Nodo* nvo_nodo = new Nodo(elemento, ptr_nodo_actual);
ptr_nodo_anterior->siguiente=nvo_nodo;

cant_nodos++;
}

template
void Lista::intercambiar_pos_nodos(int pos_1, int pos_2){
assert((pos_1>=0 || pos_1<=cant_nodos-1) && "Se desea cambiar de posicion a un nodo con posicion inválida.");//
assert((pos_2>=0 || pos_2<=cant_nodos-1) && "Se desea cambiar de posicion a un nodo hacia una posicion inválida.");//

if((pos_1==0 && pos_2==cant_nodos-1) || (pos_1==cant_nodos-1 && pos_2==0)){
Nodo* ptr_nodo_aux1=new Nodo(this->elemento_pos(0), NULL);
Nodo* ptr_nodo_aux2=new Nodo(this->elemento_pos(cant_nodos-1), NULL);
this->quitar_nodo_pos(0);
this->insertar_al_final(ptr_nodo_aux1->elemento);
this->quitar_nodo_pos(cant_nodos-2);
this->insertar_al_principio(ptr_nodo_aux2->elemento);
}
else{
if(pos_1!=pos_2){
if(pos_1>pos_2){
int aux=pos_1;
pos_1=pos_2;
pos_2=aux;
}
Nodo* ptr_nodo_aux1=new Nodo(this->elemento_pos(pos_1), NULL);
Nodo* ptr_nodo_aux2=new Nodo(this->elemento_pos(pos_2), NULL);
this->quitar_nodo_pos(pos_1);
this->insertar_nodo_pos(ptr_nodo_aux1->elemento, pos_2);
this->quitar_nodo_pos(pos_2-1);
this->insertar_nodo_pos(ptr_nodo_aux2->elemento, pos_1);
}
}
}

template
bool Lista::contiene(T elemento){
bool contenido = false ;
Nodo* ptr_nodo_actual = inicio;

while (ptr_nodo_actual != NULL) {
//cout<<"CONTIENE: "<elemento<<" == "<elemento == elemento){
contenido=true;
//cout<<"CONTIENE_RES: "<siguiente;
}
//cout<<"CONTIENE_RES: "<
class Cola : public Lista {
private:
int duenio; // ip_equipo asociado
int tamanio_max; //
public:
Cola();
Cola(int);
Cola(int, int);
~Cola();
void encolar(T);
void desencolar();
int obtener_duenio();
void reencolar();
int obtener_tamanio_max();
void fijar_tamanio_max(int);
bool cola_llena();
void imprimir();

};

template
Cola::Cola(){
//Lista();
this->duenio=-1;
this->tamanio_max=-1;
}

template
Cola::Cola(int duenio){
//Lista();
this->duenio=duenio;
this->tamanio_max=-1;
}

template
Cola::Cola(int duenio, int tamanio_max){
//Lista();
this->duenio=duenio;
this->tamanio_max=tamanio_max;
}

template
Cola::~Cola(){}

template
void Cola::encolar(T elemento){

assert(!this->cola_llena() && "Se intenta agregar elementos a una cola llena"); // si la cola esta llena, mando el mensaje
this->insertar_al_final(elemento);

}

template
void Cola::desencolar(){
Lista::quitar_primer_nodo();
}

template
void Cola::reencolar(){
T primer_elem = Lista::primer_elemento();
Lista::quitar_primer_nodo();
encolar(primer_elem);
}

template
int Cola::obtener_duenio(){
return duenio;
}

template
int Cola::obtener_tamanio_max(){
return tamanio_max;
}

template
bool Cola::cola_llena(){
return this->tamanio() == tamanio_max;
}

template
void Cola::fijar_tamanio_max(int tam_max){
this->tamanio_max = tam_max;
}

template
void Cola::imprimir(void){
Lista::imprimir();
}

class Paquete
{
private:
vector ip_comp_origen;
vector ip_comp_destino;
int id_pagina;
int tamanio_pagina;
int nro_orden; //orden del paquete = tamanio/ancho_paquete

public:
Paquete();
Paquete(vector, vector, int, int, int);
~Paquete();
vector obtener_ip_comp_origen();
vector obtener_ip_comp_destino();
int obtener_id_pagina();
int obtener_nro_orden();
int obtener_tamanio_pagina();
void imprimir();
void cambiar_orden(int);

};

Paquete::Paquete(){
this->ip_comp_origen=vector(-1,-1);
this->ip_comp_destino=vector(-1,-1);
this->id_pagina=-1;
this->tamanio_pagina=-1;
this->nro_orden=-1;
}
Paquete::Paquete(vector ip_comp_origen, vector ip_comp_destino, int id_pagina, int tamanio_pagina, int nro_orden){
this->ip_comp_origen=ip_comp_origen;
this->ip_comp_destino=ip_comp_destino;
this->id_pagina=id_pagina;
this->tamanio_pagina=tamanio_pagina;
this->nro_orden=nro_orden;
}

vector Paquete::obtener_ip_comp_origen(){
return this->ip_comp_origen;
}

vector Paquete::obtener_ip_comp_destino(){
return this->ip_comp_destino;
}

int Paquete::obtener_id_pagina(){
return this->id_pagina;
}

int Paquete::obtener_nro_orden(){
return this->nro_orden;
}

int Paquete::obtener_tamanio_pagina(){
return this->tamanio_pagina;
}

void Paquete::imprimir(){
//cout<<"PAQUETE:"<nro_orden<<" --> PÁGINA: "<id_pagina<id_pagina<<",Ro:"<ip_comp_origen[0]<<",Rd:"<ip_comp_destino[0]<<",ORD:"<nro_orden<<"]";
}

void Paquete::cambiar_orden(int nvo_nro_orden){
this->nro_orden=nvo_nro_orden;
}

Paquete::~Paquete(){

}

/*
Esta clase representa el arco o la arista de un grafo.
Es la entidad que conecta dos nodos o vértices y que se le asigna un peso o distancia.
*/
class Arco
{
private:
int nodo_origen;
int nodo_destino;
int peso_arco;
public:
Arco(int , int, int);
~Arco();
int origen();
int destino();
int peso();
void mod_peso(int);//modifica el valor del peso del Arco.
void imprimir();
};

Arco::Arco(int origen, int destino, int peso) : nodo_origen(origen),nodo_destino(destino),peso_arco(peso)
{}
Arco::~Arco(){
}
int Arco::origen(){
return this->nodo_origen;
}
int Arco::destino(){
return this->nodo_destino;
}
int Arco::peso(){
return this->peso_arco;
}
void Arco::mod_peso(int nvo_peso){
this->peso_arco=nvo_peso;
}
void Arco::imprimir(){
cout<<"["<nodo_origen<<"|"<nodo_destino<<"|"<peso_arco<<"]";
}

/*
Esta clase representa el arco de el grafo que ilustra la red a simular.
Consta de un par de terminales, la especificación del ancho de banda y
una cola para emular las limitaciones del canal.
*/
class Conexion : public Arco
{
private:
Cola canal;
public:
Conexion(int, int, int);
~Conexion();
//set obtener_terminales();
void cargar(Paquete);
Paquete leer();
int obtener_ancho_banda();
bool conexion_saturada();
bool conexion_libre();
};

Conexion::Conexion(int origen, int destino, int ancho) : Arco(origen, destino, ancho), canal(){
this->canal.fijar_tamanio_max(ancho);
}

Conexion::~Conexion(){
}
/*
set Conexion::obtener_terminales(){
return this->terminales;
}*/

void Conexion::cargar(Paquete paq){
//assert(canal.cola_llena() && "Se intenta cargar una conexion que está saturada.");
this->canal.encolar(paq);
}

Paquete Conexion::leer(){
Paquete paq_leido = this->canal.primer_elemento();
this-> canal.desencolar();
return paq_leido;

}

bool Conexion::conexion_saturada(){
return this->canal.cola_llena();
}

int Conexion::obtener_ancho_banda(){
return this->peso();
}

bool Conexion::conexion_libre(){
return this->canal.es_vacia();
}

/*
Esta clase implementa las cumplas de tres enteros que utilizará la clase
er para
determinar hacia dónde debe enviar los paquetes.
*/
class Etiqueta
{
private:
int router_destino;
int router_despacho;
int peso_trayecto;
//Lista camino;
public:
Etiqueta(int, int, int);
~Etiqueta();
int despacho();
int destino();
int peso_total();
void mod_peso_trayecto(int);//modifica peso_trayecto
void mod_despacho(int);
void imprimir();
//void agregar_nodo(int);
//Lista obtener_camino();
//void corregir(int);

};

Etiqueta::Etiqueta(int router_destino, int router_despacho, int peso_trayecto){
this->router_destino=router_destino;
//this->router_despacho=router_despacho;//router al que se debe despachar los paquetes que tienen como destino el router_destino;
this->peso_trayecto=peso_trayecto;
}
Etiqueta::~Etiqueta(){
}
int Etiqueta::despacho(){
return this->router_despacho;
}
int Etiqueta::destino(){
return this->router_destino;
}
int Etiqueta::peso_total(){
return this->peso_trayecto;
}
void Etiqueta::mod_peso_trayecto(int nvo_peso){
this->peso_trayecto = nvo_peso;
}
void Etiqueta::mod_despacho(int nvo_router_despacho){
this->router_despacho = nvo_router_despacho;
}
void Etiqueta::imprimir(){
cout<<"["<router_destino<<"|"<router_despacho<<"|"<peso_trayecto<<"]";
}

/*
Esta clase representa las páginas que generan las computadoras
y que contiene una identificación su tamaño en cantidad de paquetes y las direcciones
de origen y de destino en duplas.
*/

class Pagina
{
private:
int id;//número de la página.
int tamanio;//tamaño de la página en cantidad de paquetes
vector ip_comp_origen;//ip pc y router origen
vector ip_comp_destino;//ip pc y router destino

public:
Pagina(int, int, std::vector, std::vector);
~Pagina();
int obtener_id();
int obtener_tamanio();
std::vector obtener_ip_comp_origen();
std::vector obtener_ip_comp_destino();
void imprimir(void);
};

Pagina::Pagina(int id, int tamanio, vector ip_comp_origen, vector ip_comp_destino):id(id),tamanio(tamanio),ip_comp_origen(ip_comp_origen),ip_comp_destino(ip_comp_destino){}

Pagina::~Pagina()
{}

int Pagina::obtener_id(){
return this->id;
}

int Pagina::obtener_tamanio(){
return this->tamanio;
}

vector Pagina::obtener_ip_comp_origen(){
return this->ip_comp_origen;
}

vector Pagina::obtener_ip_comp_destino(){
return this->ip_comp_destino;
}

void Pagina::imprimir(void){
cout<<"Pagina: "<obtener_id()<obtener_tamanio()<obtener_ip_comp_origen()[0]<<"--"<obtener_ip_comp_origen()[1]<obtener_ip_comp_destino()[0]<<"--"<obtener_ip_comp_destino()[1]< ip;
Lista paginas_recibidas;
public:
Computadora(vector);
//Computadora();
~Computadora();
//void enviar_pagina(Pagina);
void recibir_pagina(Pagina);
int cant_pag_recibidas();
vector obtener_ip();
void imprimir();
};

Computadora::Computadora(vector ip) : ip(ip),paginas_recibidas(){}
/*Computadora::Computadora():ip(),paginas_recibidas(){
}*/
Computadora::~Computadora(){
}

/*void Computadora::enviar_pagina(Pagina pagina_envio){
this->router->recibir_pagina(pagina_envio);
}*/

void Computadora::recibir_pagina(Pagina pagina_recibida){
this->paginas_recibidas.agregar(pagina_recibida);
}
int Computadora::cant_pag_recibidas(){
return this->paginas_recibidas.tamanio();
}
vector Computadora::obtener_ip(){
return this->ip;
}
void Computadora::imprimir(){
cout<<"Computadora: ("<ip[0]<<"|"<ip[1]< > > clasificador;
int mi_router;
public:
Biblioteca_paquetes(int);
~Biblioteca_paquetes();
int agregar_paquete(Paquete);
Paquete obtener_paquete();
void imprimir();
int tamanio();
int destino_proa();
int hay_envios();
void reencolar_destino();
};

Biblioteca_paquetes::Biblioteca_paquetes(int mi_rout)
:clasificador(), mi_router(mi_rout){}

Biblioteca_paquetes::~Biblioteca_paquetes(){
}

int Biblioteca_paquetes::agregar_paquete(Paquete paq_recibido){
bool hay_cat_router=false;
bool hay_cat_pagina=false;
int i,j;
int router_destino = paq_recibido.obtener_ip_comp_destino()[0];
/*cout<<"-----------------------------------------------------"<0){//Si el clasificador no está vacío.
//cout<<"El clasificador no está vacío"< vec_des(clasificador.elemento_pos(i).elemento_pos(j).tamanio());
vector vec_ord(vec_des.size());
int k=0;
while(k vec_ordenado=vec_desordenado;//voy cargando en mi vector desordenado los ordenes de los paquetes de la cola.
//vec_ordenado.sort();
//ordena la cola de paquetes.
for(vector::size_type l=0; l::size_type m=0; m paquetes_nva_pag(paq_recibido.obtener_id_pagina());
paquetes_nva_pag.encolar(paq_recibido);
clasificador.elemento_pos(i).encolar(paquetes_nva_pag);
return 0;
}
}
else{//Si el clasificador NO tiene la categoría para el router destino del paquete.
//cout<<"agrega cat router"< > paginas_nvo_router(router_destino);
Cola paquetes_nva_pag(paq_recibido.obtener_id_pagina());
paquetes_nva_pag.encolar(paq_recibido);
paginas_nvo_router.encolar(paquetes_nva_pag);
clasificador.encolar(paginas_nvo_router);
return 0;
}
}
else{//Si el clasificador ESTÁ VACÍO.
//cout<<"Estaba vacio"< > paginas_nvo_router(router_destino);
Cola paquetes_nva_pag(paq_recibido.obtener_id_pagina());
paquetes_nva_pag.encolar(paq_recibido);
paginas_nvo_router.encolar(paquetes_nva_pag);
clasificador.encolar(paginas_nvo_router);
return 0;
}
return 0;

}

Paquete Biblioteca_paquetes::obtener_paquete(){
assert (clasificador.tamanio()>0 && "Se intenta obtener paquetes de la coleccion vacia");
cout<<"Hey1"<clasificador.reencolar();
}

int Biblioteca_paquetes::hay_envios(){
if(this->clasificador.tamanio()==1 && this->destino_proa() == this->mi_router)
return 0;
else
return this->clasificador.tamanio();
}

/*
Esta clase representa los nodos de la red y opera como enrutador, tiene las funcionalidades de
enviar y recibir paquetes así como recibi páginas completas desde las computadoras que están conectadas a este router.
*/
class Router
{
private:
int ip;
Lista computadoras;
Lista tabla_enrutamiento;
Biblioteca_paquetes organizador_paquetes;
Lista conexiones_envio;
Lista conexiones_recepcion;

public:
Router(int);
~Router();
//Router(int, Lista<*Computadora>, Lista, Lista);
void recibir_pagina(Pagina);
void recibir_paquetes();
void leer_conexiones();
void enviar_paquetes();
void cargar_conexiones();
int buscar_en_tabla(int);
void enviar_pagina(Pagina);
Pagina construir_pagina(Paquete);
void mostrar_paquetes();
void agregar_conexion_envio(Conexion*);
void agregar_conexion_recepcion(Conexion*);
int obtener_ip();
int total_paquetes();
void actualizar_tabla(Lista);
void agregar_computadora(Computadora);
void imprimir();
};

Router::Router(int ip_router):ip(ip_router),computadoras(),tabla_enrutamiento(),organizador_paquetes(ip_router),conexiones_envio(),conexiones_recepcion(){}

Router::~Router(){
}

void Router::recibir_pagina(Pagina pagina_recibida){
for(int i=0;iorganizador_paquetes.agregar_paquete(Paquete(pagina_recibida.obtener_ip_comp_origen(), pagina_recibida.obtener_ip_comp_destino(), pagina_recibida.obtener_id(), pagina_recibida.obtener_tamanio(),i));
}
}

void Router::recibir_paquetes(){
//cout<<"Router::recibir_paquetes()"<leer_conexiones();

}

void Router::leer_conexiones(){
//cout<<"Router::leer_conexiones()"<ip<<" y tengo "<conexion_libre()<conexion_libre()){//Mientras que la conexión en la posición i de la lsita de conexiones no esté libre...
Paquete paq_leido=conexiones_recepcion.elemento_pos(i)->leer();//esta instruccion terminará por liberar la conexion y finalizar el while.
cout<<"Hola2"<organizador_paquetes.agregar_paquete(paq_leido);
/////////////SETEAR PAGINA COMPLETA COMO FALSE PREVIAMENTE
cout<<"Hola3"<construir_pagina(paq_leido);//en la realidad la computadora se encarga de generar la pagina
this->enviar_pagina(pag_construida);
}
//cout<<"Hola4"<cargar_conexiones();

}
void Router::cargar_conexiones(){//envia el mensaje pero no espera una respuesta de recepcion exitosa UTP!
bool conexiones_saturadas=false;
while(organizador_paquetes.hay_envios() && !conexiones_saturadas){//mientras hayan paquetes en el organizador para envío y las conexiones no esten saturadas
cout<<"Chau1"<organizador_paquetes.obtener_paquete();//aqui se puede vaciar el organizador_paquetes -->corta el while
//cout<<"Paquete:"<ip)
organizador_paquetes.reencolar_destino();
cout<<"Chau3"<buscar_en_tabla(organizador_paquetes.destino_proa())<destino()<< "--SAT?-- "<conexion_saturada()<destino() == this->buscar_en_tabla(organizador_paquetes.destino_proa()) && !conexiones_envio.elemento_pos(i)->conexion_saturada()){

//PRIMER CONDICION APARTE B) NO ESTA SATURADA LA PRIMER CONEXION DE ENVIOS == BOOL
//INT DESTINO_PARA_COMP;
// INT DESTINO_A_COMP = conexiones_envio.elemento_pos(i)->destino();
//TAM_FOR = organizador_paquetes.TAMANIO()
//FOR(INT X=0; X < TAM_FOR; X++)
//{DESTINO_PARA_COMP = this->buscar_en_tabla(organizador_paquetes.destino_proa()
//WHILE(DESTINO_A_COMP == DESTINO_PARA_COMP)
//
cout<<"Chau4"<cargar(organizador_paquetes.obtener_paquete());
}
conexiones_saturadas=conexiones_saturadas && conexiones_envio.elemento_pos(i)->conexion_saturada();//Aqui corta el while si las conexiones estan saturadas.
}
}
}

int Router::buscar_en_tabla(int destino){
tabla_enrutamiento.imprimir();
cout<<"Tamanio de tabla: "< \"No se encontró la etiqueta para el destino del paquete.\"");
}

void Router::mostrar_paquetes(){
cout<ip<<":"<< BOLD_BLUE "TOTAL DE PAQUETES: "<organizador_paquetes.tamanio()<ip<<":"<organizador_paquetes.imprimir();
cout<conexiones_envio.agregar(con);
}

void Router::agregar_conexion_recepcion(Conexion* con){
this->conexiones_recepcion.agregar(con);
}

int Router::obtener_ip(){
this->computadoras.tamanio();
return this->ip;
}

int Router::total_paquetes(){
return this->organizador_paquetes.tamanio();
}

void Router::actualizar_tabla(Lista nva_tabla){
Lista tabla = nva_tabla;
cout<<"000000000000000000000000000000000000000000"<tabla_enrutamiento=tabla;
tabla_enrutamiento.imprimir();
cout<<"111111111111111111111111111111111111111111"<ip<imprimir();
cout<imprimir();
cout< routers;
Lista arcos;
Lista conexiones;
int cant_comp_por_router;
int cant_routers;
int total_pag;
int cant_pasos;

public:
Administrador();
~Administrador();
void simular_cant_pasos(int);
void simular_un_paso(bool);
Lista Dijkstra(int);
void calcular_tablas();
void leer_archivo();
//void crear_conexiones();
int dibujar_grafo();
void crear_pagina();
void probar_conf();
};

Administrador::Administrador()
:routers(),arcos(),conexiones(),cant_comp_por_router(0),cant_routers(0),total_pag(0),cant_pasos(1){}

Administrador::~Administrador(){
}

void Administrador::simular_cant_pasos(int cant_pasos){

for(int i=0; isimular_un_paso(false);
}
}

void Administrador::crear_pagina(){
//Cada cierta cantidad de pasos de simulacion (5) se generaran paginas aleatorioas de compuatadoras aleatorias.
//
unsigned int seed;
FILE* urandom = fopen("/dev/urandom", "r");
/////////////7 CAMBIAR UBICACION DEL ARCHIVO
fread(&seed, sizeof(int), 1, urandom);
fclose(urandom);
srand(seed);
//srand(time(0));
int i = rand() % (cant_routers);
//srand(time(0));
int j = rand() % (cant_comp_por_router);//el +1 vá por definición de rand().
int arreglo1[2]={i,j};
vector ip_comp_origen(arreglo1,arreglo1+sizeof(arreglo1)/sizeof(arreglo1[0]));
srand(time(0));
int k = rand() % (cant_routers);
//srand(time(0));
int l = rand() % (cant_comp_por_router);
int arreglo2[2]={k,l};
vector ip_comp_destino(arreglo2,arreglo2+sizeof(arreglo2)/sizeof(arreglo2[0]));
Pagina nva_pag(total_pag, rand()%(TAM_MAX_PAG+1-TAM_MIN_PAG)+TAM_MIN_PAG, ip_comp_origen, ip_comp_destino);
cout<<"SE CREO UNA NUEVA PAGINA: "<calcular_tablas();
cout<<"Estoy en el if"<=0){
cout<<"Estoy en el while"<crear_pagina();//Se crearán tantas páginas como routers tiene el sistema.
bandera--;
}
}
if((cant_pasos % 5) == 0){//Cada 5 pasos de simulación se crea una página.
this->crear_pagina();
}
if((cant_pasos % 30) == 0){//Cada 30 pasos de simulación se recalculan las tablas de enrutamiento por lo que debe actualizarse el peso de todos los arcos.
cout<destino()).total_paquetes()/conexiones.elemento_pos(i)->peso();
// EL NUEVO PESO SERA : [MEDIANTE EL DESTINO DE LA CONEXION-I,OBTENEMOR EL ROUTER DESEADO, PARA CALCULAR LA CANTIDAD DE PAQUETES] % EL PESO DE DICHA CONEXION-I
assert(nvo_peso>0 && "peso de arco negativo");
if(nvo_peso!=0)
arcos.elemento_pos(i).mod_peso(nvo_peso);
}
this->calcular_tablas();
}
cout<<"Tamanio de Routers"<cant_pasos++;
}

Lista Administrador::Dijkstra(int nodo_inicio){
Lista S;
Lista Q;
Lista etiquetas;
Lista adyacentes;
//Lista predecesores;
vector predecesores(cant_routers);
cout<origen()==nodo_elegido){//Si el arco tiene como orígen el nodo que estamos analizando. Osea corroboro sobre los que son adyancentes al nodo_elegido.
if(!S.contiene(arco_actual->destino())){//Si el destino de ese arco NO está dentro de los nodos calculados.
etiqueta_vieja = & etiquetas.elemento_pos(arco_actual->destino());
peso_tray_nvo=etiquetas.elemento_pos(nodo_elegido).peso_total()+arco_actual->peso();
//RELAJO - ACTUALIZO
if(etiqueta_vieja->peso_total()>peso_tray_nvo){//Si el peso del trayecto de la etiqueta vieja es mayor que el peso del trayecto calculado.
etiqueta_vieja->mod_peso_trayecto(peso_tray_nvo);
//predecesores.insertar_nodo_pos(nodo_elegido, arco_actual->destino());
predecesores[arco_actual->destino()]=nodo_elegido;
}
}
}
}
}

for(size_t i=0;i tabla = this->Dijkstra(i);
cout<<"||||||||||||||||||||||||||||||||||||||"<> nro)) {
cout<<"Error en la lectura de la cantidad de routers."<> nro)) {
cout<<"Error en la lectura de la cantidad de computadoras por router."< ip_comp_i_j(arreglo,arreglo+sizeof(arreglo)/sizeof(arreglo[0]));
//Router* ptr_router_i=&routers.elemento_pos(i);//puntero al router de la posicion i de la lista de routers de la red.

Computadora computadora_i_j(ip_comp_i_j);
//computadora_i_j.imprimir();
//cout<> origen >> destino >> ancho_banda)) {
cout<<"Error en la lectura de la conexion de router."<imprimir();
cout<origen()).agregar_conexion_envio(ptr_conexion);//El router que corresponde al orígen de la conexión va a cargar paquetes.
routers.elemento_pos(ptr_conexion->destino()).agregar_conexion_recepcion(ptr_conexion);//El router que corresponde al destino de la conexión va a leer los paquetes cargados en el canal.
Arco nvo_arco(origen, destino, ancho_banda);
arcos.agregar(nvo_arco);
}
break;
}
}
}

int Administrador::dibujar_grafo(){

FILE * f = popen( "date +\"%m-%d_%H-%M-%S\"", "r" );
if ( f == 0 ) {
fprintf( stderr, "No se pudo ejecutar \"date\".\n" );
return 1;
}
const int BUFSIZE = 1000;
char buf[ BUFSIZE ];
fgets( buf, BUFSIZE, f );
cout< m"<::iterator it_1 = conexiones.elemento_pos(k).terminales().begin();
set::iterator it_2 = it_1++;
flujo_salida<<*it_1<<" -- "<<*it_2<<" [color=blue,penwidth=3.0]"< "<imprimir();
cout<>comando;
if(comando>0){
if(comando==1){
cout<<"Simulación de un paso"<

Imagen de Jose Luis 1320
+1
0
-1

estoy trabajando en Win 7 32 bits con wxDev c++, en la imagen aparece con que compila y hace debugging.

Aqui no se tratan problemas con Windows, y en un foro de Ubuntu no se tratan temas de programación en un sistema operativo ajeno a GNU/linux y con un compilador que también es ajeno.

El mensaje de error es muy claro... te falta declarar una tubería ¿que tuberia? yo no lo sé... es cuestion de que revises tu código, no se si tu compilador indica en donde esta el error, pero debe de hacerlo.

Por favor recurre al foro apropiado, Gracias.

+1
0
-1

"Yo sólo se que no se nada"
-Sócrates, filósofo griego.
-Normas del foro