Lectura de archivo en C++

[kelvi]

Hola a todos,

Hace mucho que no programo en C++ y estoy peleandome intentando hacer lo siguiente:

Tengo un archivo, out.tr, que es del siguiente estilo:

+ 2.272251 6 7 cbr 210 ------- 0 0.0 7.0 138 211
- 2.272251 6 7 cbr 210 ------- 0 0.0 7.0 138 211
r 2.273528 2 5 pareto 210 ------- 2 2.0 9.0 187 803
+ 2.273528 5 6 pareto 210 ------- 2 2.0 9.0 187 803

Mi intención es poder leerlo y poner cada uno de los valores en una variable. De momento he conseguido lo siguiente:

#include <iostream>
#include <iomanip>
#include <fstream>
#include <stdio.h>
#include <string.h>

using namespace std;

int main() {
char * pch;
char origen[2],desti[2];
char event,emisor,receptor,flux;
string linia;
//DECLARACIO VARIABLE FITXER
ifstream fitxer;
//OBRIR FITXER LECTURA
fitxer.open("TCL/out.tr");
if (!fitxer) {
cerr << "Error al llegir fitxer";
return 1;
}
while(getline(fitxer,linia))
{
char liniaString[linia.length()];
for (int i=0; i<=linia.length() ; i++){
liniaString[i]=linia[i];
}
pch=strchr(liniaString,' ');
event=liniaString[pch-liniaString-1];
pch=strchr(pch+1,' ');
emisor=liniaString[pch-liniaString+1];
pch=strchr(pch+1,' ');
receptor=liniaString[pch-liniaString+1];
for (int i = 0; i<4 ; i++){
pch=strchr(pch+1,' ');
}
flux=liniaString[pch-liniaString+1];
pch=strchr(pch+1,' ');
for (int i=0; i<3; i++){
origen[i]=liniaString[pch-liniaString+i+1];
}
pch=strchr(pch+1,' ');
for (int i=0; i<3; i++){
desti[i]=liniaString[pch-liniaString+i+1];
}

}
fitxer.close();
return 0;
}

Aquí aún no he cogido todos los datos pero sí los más importantes(los campos 1,2,3,8,9 y 10). Mi intención ahora es poder coger cada uno de los campos pero no encuentro la manera mas eficiente. No habría algún método para poder ir leyendo el fichero hasta encontrar un espacio y asignarlo a una variable?

Alguien me podría sugerir alguna solución muchas gracias de antemano.

Fran

[vosk]

"...habría algún método para poder ir leyendo el fichero hasta encontrar un espacio..."

Si, se llama tokenizar y hay una funcion estandar de c llamada 'strtok' que se encarga de cortar una cadena de texto por el caracter que le indiques; esta funcion tiene algun pequeño fallo: modifica el texto y no es fiable en multiprocesos, para eso puedes encontrar por ahi una implementacion paralela llamada 'strtok_r' que se define como la version reentrante (no modifica los datos y es compatible con multiprocesos). Ademas seguramente tendras algo implementado en c++, no se.

La idea es la siguiente: lees linea por linea con 'getline' i aplicas strtok al resultado para encontrar cada campo de la linea de datos. Inicialmente tienes una struct per organitzar una mica el resultat (lo ideal sería un array de structs donde cargas todos los datos encontrados) y cada campo del archivo de datos se carga en un a variable del struct

Código:

+ 2.272251 6 7 cbr 210 ------- 0 0.0 7.0 138 211

EL '+' será un modificador, el '2.272251' será 'l1', el '6' será 'l2', etc... me he inventado los nombres pero para el ejemplo ya sirve. Ahora defines una lista de campos esperados

Código:

enum ID_CAMPS {
    MOD,
    L1, L2, L3, L4, L5,
    SEP,
    R1, R2, R3, R4, R5
};

Esto es solo una descripcion de los campos de cada linea, no implica ni comprovaciones de error de formato ni tipo de dato ok? Luego declaras un incremental para cada campo de la linea (se supone que las lineas estaran en un formato estandar), y lo aplicas con el getline y strtok

Código:

int camp;//incremental
while(getline(fitxer, linia)) {

        camp = MOD;
        pch = strtok((char *)linia.c_str(), " ");

        while(pch != NULL) {
            switch(camp) {
                case MOD: {
                    
                }
                break;
                case L1: {
                    
                }
                break;
                //etc para todos los campos esperados
            }
            
            pch = strtok (NULL, " ");
            camp++;
        }
    }

Ok? Ahora tienes controlado el campo, y para cada campo defines el tipo de dato: si estas en MOD (segun el ejemplo de contenido que colgaste, seran los tipos posibles +-r) lo guardas en un char, si estas en L1 (se espera un punto flotante) aplicas atof y lo guardas en un float, luego hay dos enteros, un separador, otro entero, dos flotantes y otros dos enteros.

Con el incremental sabes que al finalizar ciclo de strtok para cada linea tienes que haber llegado a R5, con eso puedes añadir un control de error para saber si hay alguna linea de datos mal formateada.

Si ademas declaras un struct con los datos esperados lo tendras un poco mas organizado

Código:

typedef struct {
    char MOD;
    float l1;
    int l2, l3;
    ...etc
} DADES_ARXIU;

Para cada campo formateas segun el tipo esperado

Código:

DADES_ARXIU camps;
case L1: {
    camps.l1 = atof(pch);
}
break;
etc...

Y ya luego al final implementas un array (en c++ puedes usar vectores) con todos los datos leidos:

Código:

using namespace std;
vector <DADES_ARXIU> llista;
DADES_ARXIU camps;
while(pch != NULL) {
    //aqui rellenas una struct con los datos leidos
}

//y al final añades a la lista
llista.push_back(camps);
//recuerda que al finalizar la aplicacion deberas liberar la memoria usada por el vector

Otra cosa, indenta un poco el codigo.

Salut
vosk

[iblancasa]

Edito: me equivoqué y no puedo borrar el post.

[kelvi]

Muchas Gracias por la rapidez. Ahora miro a ver si puedo hacerlo!!

Ahora tengo esto

Código C++:

#include <iostream>
#include <iomanip>
#include <fstream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <list>
 
using namespace std;
 
typedef struct {
    char EV;
    float T;
    int E,R;
    string P;
    float G;
    string FLA;
    int FLU;
    float O,D,S,I;
} DADES_ARXIU;
 
enum ID_CAMPS{EV,T,E,R,P,G,FLA,FLU,O,D,S,I};
 
int main() {
    list <DADES_ARXIU> llista;
    DADES_ARXIU camps;
    int camp;//incremental
    char * pch;
    string linia;
 
    //FITXER DE LECTURA 
    ifstream fitxer;
    fitxer.open("TCL/out.tr");
    if (!fitxer) {
        cerr << "Error al llegir fitxer";
        return 1;
    }
 
    while(getline(fitxer,linia)){   
    
        camp = EV;
        pch = strtok((char*)linia.c_str(), " ");
        while(pch != NULL){
            switch(camp) {
                case EV: {                  
                                //camps.EV = pch.c_srt();
                        }break;
                case T: {
                    //camps.T = atof(linia[pch]);                    
                }break;
                case E: {
                    //camps.E = atoi(pch);                    
                        }break;
                case R: {
                    //camps.R = atoi(pch);                    
                }break;
                case P: {
                    camps.P = pch;                    
                        }break;
                case G: {
                    //camps.G = atof(pch);                   
                }break;
                case FLA: {
                    camps.FLA = pch;                
                        }break;
                case FLU: {
                    //camps.FLU = atoi(pch);       
                }break;
                case O: {
                    //camps.O = atof(pch);                    
                        }break;
                case D: {
                    //camps.D = atof(pch);                    
                }break;
                case S: {
                    //camps.S = atoi(pch);                    
                        }break;
                case I: {
                    //camps.I = atoi(pch);                    
                }break;
            }
            pch = strtok (NULL, " ");
            llista.push_back (camps);
            camp++;
        }
    if(camp>12){ cout << "ERROR DE FITXER"; return 1;}
    }
    fitxer.close();
    return 0;
}
 

Aunque parezca un separador, el campo SEP, en mi código FLA, realmente no es un separador son banderas, cada uno de los guiones puede tomar un valor char.

R2 y R3, en mi código O y D, también me interesaría verlos como char. Ya que por ejemplo si es 1.0 cada una de las dos cifras me indica una cosa distinta.

Cuando lanzo el programa me da errores dentro del switch por eso tengo las asignaciones puestas en comentarios.

Si quito este comentario:

Código C++:

//camps.EV = pch;
 

Me da el siguiente error:

lectura.cpp: En la función ‘int main()’:
lectura.cpp:45:35: error: conversión inválida de ‘char*’ a ‘char’ [-fpermissive]


Y si quito este:

Código C++:

//camps.T = atof(pch);
 

Me da este otro error:

lectura.cpp: En la función ‘int main()’:
lectura.cpp:48:30: error: conversión inválida de ‘char*’ a ‘unsigned int’ [-fpermissive]
/usr/include/c++/4.6/bits/basic_string.h:835:7: error: argumento de inicialización 1 de ‘std::basic_string<_CharT, _Traits, _Alloc>::reference std::basic_string<_CharT, _Traits, _Alloc>::operator[](std::basic_string<_CharT, _Traits, _Alloc>::size_type) [con _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>, std::basic_string<_CharT, _Traits, _Alloc>::reference = char&, std::basic_string<_CharT, _Traits, _Alloc>::size_type = unsigned int]’ [-fpermissive]
lectura.cpp:48:31: error: conversión inválida de ‘char’ a ‘const char*’ [-fpermissive]
/usr/include/stdlib.h:145:15: error: argumento de inicialización 1 de ‘double atof(const char*)’ [-fpermissive]

Como podría solucionarlo??

Perdón si pregunto demasiado pero es que estoy hecho un lio.
Gracias otra vez!

[vosk]

Estas mezclando tipos con objetos, en las lineas 46 y 49 tienes

Código:

camps.EV = pch.c_srt();//ojo con la sintaxi: c_srt no es c_str
...
camps.T = atof(linia[pch]);

El metodo 'c_str()' forma parte de la libreria string y se aplica sobre objetos 'string', pero en la primera linea lo estas aplicando a un tipo char*; en la otra linea parece como si intentaras enviar a la funcion 'atof' un caracter de un objeto string, pero no funciona de esta manera: para el atof puedes enviarle directamente el pch porque es un char*

Si quieres asignar un char* a un char tienes que hacerlo de la forma mas facil:

Código:

camps.EV = pch[0];

char* es un array de char, por eso le asignas el primer elemento; para hacer esto es necesario la comprovacion de error de que pch no sea nulo, pero como en este caso es la misma condicion del ciclo no necesitas hacerlo y en ningun caso te puede dar error.


"...en mi código O y D, también me interesaría verlos como char. Ya que por ejemplo si es 1.0 cada una de las dos cifras me indica una cosa distinta...."

Lo tienes muy fácil, cambia el tipo float por un string (o añade un string) y asignale el pch

Código:

typedef struct {
    etc..
    float O;
    string sO;
} DADES_ARXIU;

case O: {
    camps.O = atof(pch);
    camps.sO = pch;
}
break;

O si quieres hacerlo mas divertido puedes guardarlo de forma dinamica y quedas como un señor:

Código:

typedef struct {
    etc..
    char *cO;
} DADES_ARXIU;

case O: {
    camps.cO = new char[strlen(pch)];
    memcpy(camps.cO, pch, strlen(pch));
}
break;

Si lo haces asi recuerda que para finalizar no hay suficiente con llista.clear() (que por cierto te lo has dejado), tendras que recorrer todos los elementos para hacer delete[]cO y al final llista.clear()

Otra cosa, la nueva estructura cargada tienes que añadirla a la lista al salir del ciclo 'while(pch)' y tu la estas añadiendo al evaluar cada campo de forma que te queda una llista de (nºcampos*nºfilas) cuando deberia quedarte una llista solo de (nºfilas):

Código:

while(getline(fitxer,linia)) {
    camp = EV;
    pch = strtok((char*)linia.c_str(), " ");
    while(pch) {
        switch(camp) {
            ...
        }
        pch = strtok (NULL, " ");
        camp++;
    }
    if(camp != I+1) {
        cout << "ERROR DE FITXER";
        return 1;
    }
    llista.push_back (camps);
}

Aun otra cosa, deberias implementar algo para vaciar la struct 'camps' antes de entrar al ciclo while(pch) porque representa que vas a cargar una nueva linea de datos


vosk

[kelvi]

Gracias de nuevo Vosk,

No acabo de entender esta parte:

".. Si lo haces así recuerda que para finalizar no hay suficiente con llista.clear() (que por cierto te lo has dejado), tendrás que recorrer todos los elementos para hacer delete[]cO y al final llista.clear().."

Estaría agradecido si pudieras comentarme-lo de otra forma a ver si lo pillo jejeje

He vuelto a aplicar cambios y ahora tengo lo siguiente:

Código C++:

#include <iostream>
#include <iomanip>
#include <fstream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <list>
 
using namespace std;
 
typedef struct {
    char EV;
    float T;
    int E,R;
    string P;
    float G;
    string FLA;
    int FLU;
    char *O,*D;
    float S,I;
} DADES_ARXIU;
 
enum ID_CAMPS{EV,T,E,R,P,G,FLA,FLU,O,D,S,I};
 
int main() {
    list <DADES_ARXIU> llista;
    DADES_ARXIU camps;
    DADES_ARXIU zero = {0};
    int camp;//incremental
    char * pch;
    string linia;
    //FITXER DE LECTURA 
    ifstream fitxer;
    fitxer.open("TCL/out.tr");
    if (!fitxer) {
        cerr << "Error al llegir fitxer";
        return 1;
    }
 
    while(getline(fitxer,linia)){   
    
        camp = EV;
        pch = strtok((char*)linia.c_str(), " ");
        while(pch != NULL){
            switch(camp) {
                case EV: {                  
                                camps.EV = pch[0];
                        }break;
                case T: {
                    camps.T = atof(pch);                    
                }break;
                case E: {
                    camps.E = atoi(pch);                    
                        }break;
                case R: {
                    camps.R = atoi(pch);                    
                }break;
                case P: {
                    camps.P = pch;                    
                        }break;
                case G: {
                    camps.G = atof(pch);                   
                }break;
                case FLA: {
                    camps.FLA = pch;                
                        }break;
                case FLU: {
                    camps.FLU = atoi(pch);       
                }break;
                case O: {
                    //camps.O = new char[strlen(pch)];
                    //memcpy(camps.O,pch,strlen(pch));                  
                        }break;
                case D: {
                    //camps.D = new char[strlen(pch)];
                    //memcpy(camps.D,pch,strlen(pch));                    
                }break;
                case S: {
                    camps.S = atoi(pch);                    
                        }break;
                case I: {
                    camps.I = atoi(pch);                    
                }break;
            }
            pch = strtok (NULL, " ");
            camp++;
        }
    if(camp != I+1){ cout << "ERROR DE FITXER"; return 1;}
    llista.push_back (camps);
    //VACIAR STRUCT
    camps = zero;
    }
    fitxer.close();
    llista.clear();
    return 0;
}
 

La parte de vaciar el struct en cada repetición del bucle no estoy muy seguro si lo hace bien pero la intención es que así lo haga.

Un Saludo,
Fran

[vosk]

La parte que no acabas de entender se basa en una regla muy simple: toda la memoria que bloqueas con 'new' tienes que liberarla con 'delete'. En este caso puedes hacer lo mismo con 'malloc' y 'free' porque estas trabajando con tipos char (con objetos no es aplicable).

Para liberar los campos O y D tienes que recorrer toda la lista y aplicarles el delete:

Código:

void buida_llista(list <DADES_ARXIU> *llista) {
    list <DADES_ARXIU>::iterator itr;
    
    for(itr = llista->begin(); itr != llista->end(); itr++) {
        delete [] (*itr).O;
        delete [] (*itr).D;
    }
    
    llista->clear();
}

//al finalizar llamas a la funcion
buida_llista(&llista);

La parte de bloquear memoria que la tienes comentada está bien:

Código:

case O: {
    camps.O = new char[strlen(pch)];
    memcpy(camps.O, pch, strlen(pch));                  
}
break;

Supongo que ya te habras dado cuenta: se guardan los caracteres sin dejar espacio para un \0 de final de texto; esto significa que si necesitas volcarlo a pantalla se puede dar el caso de que te muestre los caracteres seguidos de basura.

Y si no lo terminas de ver claro y no quieres liarte puedes dejar los campos O Y D como string y asignarles el pch tal como haces con P y FLA, pero es mas aburrido de programar.

Y la parte de reiniciar la struct no se si está bien pero me da la impresion de que no:

Código:

DADES_ARXIU zero = {0};

Con esto asignas 0 al primer elemento del struct, pero los demas ni se enteran. Si no llevara objetos (el string es un objeto) podrias aplicarle un memset y ya estaria; para ir sobre seguro me parece que deberias inicializar todos los campos del struct zero:

Código:

DADES_ARXIU zero = {0, 0, 0, 0, "", 0, "", 0, 0, 0, 0, 0};

Y para reiniciar el 'camps' le aplicas un memcpy y lo dejas como nuevo:

Código:

memcpy(&camps, &zero, sizeof(DADES_ARXIU));

vosk

[kelvi]

Muchas Gracias! Parece que ya funciona!! Ahora seguiré con la siguiente parte!!

Un último apunte es que he visto que la función:

Código C++:

pch = strtok((char*)linia.c_str(), " ");
 

Me modifica el "string linia", como podría salvar-lo? He estado probando

Código C++:

linia.copy(liniacopia,linia.length,0);
 

pero no consigo que termine de funcionar.

Mas que nada porqué lo utilizo como programa de filtrado de un archivo y ya me va bien el formato que está.
Con todo el código lo que hago es coger las líneas que necesita el usuario y escribirlas en otro fichero del mismo formato el qual queda filtrado. Por esa razón me interesa mantener "linia".

Fran.

[vosk]

Creo que ya te habia comentado antes lo de una version reentrante de strtok llamada strtok_r que no modifica el original, y tambien creo que te comenté que seguramente hay algun equivalente en c++ para tokenizar strings sin modificar el original (yo lo ignoro, es cuestion de googlear un poco).

El problema de strtok es que guarda el primer argumento en una global y lo reutiliza cuando vuelves a llamar strtok con el primer argumento nulo. En cambio, la strtok_r solicita un buffer extra que es donde guarda los datos modificados que guardaría en la global en su equivalente no reentrante, y por eso no toca el original.

Creo que te será facil encontrar strtok_r en FreeBSD, y mas sitios con copias e implementaciones. El uso es muy simple: proporcionas un buffer original, un texto de tokenizacion y un buffer para la reentrada (este ultimo asegura que no se modifique el original); el bucle de tokenizacion será igual que con strtok:

Código:

char *pch, *mem;

pch = strtok_r((char*)linia.c_str(), " ", &mem);
while(pch) {
    pch = strtok_r(0, " ", &mem);
}
//aqui sigues teniendo la variable 'linea' intacta

Ten en cuenta que la funcion strtok_r no forma parte del estandar de C (y por supuesto tampoco de c++), por lo que algunas implementaciones que puedas encontrar estaran sometidas a licencias y cosas de esas que nadie se mira pero que si estan ahi de algo deben servir, no se.

Si no te convence lo del strtok_r, puedes ir a lo facil y duplicar la linea para trabajar con el duplicado, de esa forma te será igual si se modifica o no (que es lo que intentabas hacer con linia.copy).

De todas formas, ya que estas trabajando en c++ tal vez deberías buscar la forma de hacerlo con strings en vez de usar las funciones de C; para la version de strtok en c++ lo siento pero no puedo ayudarte, tal vez alguien mas pueda echarte un cable

vosk

[kelvi]

Vale gracias. Probaré con stock_r y si no acabo solucionando-lo probare en copiar la variable.

Un Saludo y gracias,
Fran

[kelvi]

Hola de nuevo,

Habría la posibilidad de... a ver si me explico:

Necesitaría leer el archivo línea a línea tal i como se ha hecho hasta ahora.

Pero una vez leída la linea tengo que mantener-la y trabajar con los datos obtenidos.

Lo que se conseguiría trabajando antes de que termine el bucle de la linea.

Hasta aquí bien.

Si lo que quiero es volver a hacer una lectura manteniendo esa línea para comparar algunos datos? Como podría hacer-lo? Yo había pensado algo como:

Código C++:

while(getline(fitxer,linia)){
        //Codigo usado hasta ahora
        while(getline(fitxer,relinia)){
        //Codigo usado hasta ahora con otra variable
        //Trabajar para comparar con la otra linea
        }
    }
 

Podría ser posible?
Fran

[iblancasa]

Si te he leído bien, lo que quieres hacer es mantener las líneas que vas leyendo tal cual las lees.
Podrías usar la biblioteca <vector> de C++ y hacer un vector de vectores. En el vector más externo, la posición 0 sería la línea 1, la posición 1 la línea 2...
Un saludo.

[vosk]

Esto ya lo tiene implementado, solo que en vez de vectores esta usando listas: el elemento L#0 de la lista es la linea F#0 del archivo, el L#1 es F#1, asi hasta el total de lineas del archivo que será igual al size() de elementos de la lista. Con esto puedes comparar los datos ya parseados simplemente accediendo al indice de linea que se correspondera con el indice de lista, nada mas sencillo.

Si por lo contrario quieres hacer comparaciones de la linea textual sin tener que repaginar una nueva linea desde los datos parseados y sin tener que releer el archivo, solo tienes que añadir un string al struct de datos, en el momento de leer guardas una copia y listos:

Código:

typedef struct {
    string str_linia_font;
} DADES_ARXIU;


while(getline(fitxer,linia)) {
    ...
    while(pch != NULL) {
        switch(camp) {
            ...
        }
        ...
    }
    ...

    camps.str_linia_font = linia;
    llista.push_back(camps);
    ...
}

Facil no? De esta forma tienes las dos opciones: el indice del elemento dentro de la lista equivale al indice de linea dentro del archivo, y el string de ese elemento es una copia de la linea leida.

Tambien puedes usar esta linea como argumento de letcura en 'while(getline(fitxer, linia)) {}', luego segun el post anterior o bien usas strtok_r o haces una copia y parseas con strtok sobre la copia, de esta forma tendras intacta la linea leida dentro del struct

Código:

//string linia;  //no necesitas esta variable
while(getline(fitxer, camps.str_linia_font)) {
    ...
}

Depende del tipo de comparaciones que quieras hacer, usaras una opcion u otra: la primera ya la tienes, la segunda consiste en un simple string.

vosk

[iblancasa]

Iniciado por vosk

Esto ya lo tiene implementado[...]

Lo he leído un poco por encima, pensaba que no lo tenía.
Un saludo.

[kelvi]

Hola de nuevo,

Primero de todo espero que hayan pasado unas buenas fiestas!

Al final decidí anular el tema de la lista porqué no lo acababa usando.

Creo que no terminé de explicar-me en mi último post.

Lo que yo quiero es:

Una vez obtenida la primera linea del fichero necesito volver a leer todo el fichero para encontrar otra linea de unas características. Y así para cada una de las lineas.

A ver si me explico... yo leo la primera linea por ejemplo:

Código Texto:

+ 0.1 0 3 tcp 40 ------- 1 0.0 5.2 0 0
 

La cual ya tendré separada por los campos. Esta linea significa que se a generado un paquete.

Pues ahora necesito comparar esta linea con todas las del fichero para encontrar la siguiente:

Código Texto:

r 0.130067 4 5 tcp 40 ------- 1 0.0 5.2 0 0
 

Que significa que el nodo de destino a recibido ese paquete.

Por eso mismo necesito hacer una re lectura del fichero por cada linea obtenida o al menos hasta encontrar su linea pertinente. (Que eso ya sería un if que rompa el bucle)

Este es mi código por ahora:

Código C++:

#include <iostream>
#include <iomanip>
#include <fstream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sstream>
 
using namespace std;
 
typedef struct {
    char EV;
    float T;
    int E,R;
    string P;
    float G;
    string FLA;
    int FLU;
    string O,D;
    float S,I;
} DADES_ARXIU;
 
enum ID_CAMPS{EV,T,E,R,P,G,FLA,FLU,O,D,S,I};
 
int main() {
    DADES_ARXIU camps;
    DADES_ARXIU zero = {0, 0, 0, 0, "", 0, "", 0, "", "", 0, 0};
    int camp;//incremental
    char *pch, *copia;
    string linia;
    //FITXER DE LECTURA 
    ifstream fitxer;
    fitxer.open("Proces/out.tr");
    if (!fitxer) {
        cerr << "Error al llegir fitxer";
        return 1;
    }
 
    while(getline(fitxer,linia)){   
        copia = new char [linia.size()+1];
        strcpy (copia,linia.c_str());
        camp = EV;
        pch = strtok(copia, " ");
        while(pch != NULL){
            switch(camp) {
                case EV: {                  
                                camps.EV = pch[0];
                        }break;
                case T: {
                    camps.T = atof(pch);                    
                }break;
                case E: {
                    camps.E = atoi(pch);                    
                        }break;
                case R: {
                    camps.R = atoi(pch);                    
                }break;
                case P: {
                    camps.P = pch;                    
                        }break;
                case G: {
                    camps.G = atof(pch);                   
                }break;
                case FLA: {
                    camps.FLA = pch;                
                        }break;
                case FLU: {
                    camps.FLU = atoi(pch);       
                }break;
                case O: {
                    camps.O = pch;               
                        }break;
                case D: {
                    camps.D = pch;                   
                }break;
                case S: {
                    camps.S = atoi(pch);                    
                        }break;
                case I: {
                    camps.I = atoi(pch);                    
                }break;
            }
            pch = strtok (NULL, " ");
            camp++;
        }
    if(camp != I+1){ cout << "ERROR DE FITXER"; return 1;}
    //BUIDAR STRUCT
    memcpy(&camps, &zero, sizeof(DADES_ARXIU));
    //BUIDAR CHAR
    delete[] copia;
    }
    fitxer.close();
    return 0;
}
 

Saludos,
Fran

[vosk]

Ok, la solucion anterior de la lista esta mal planteada, y la solucion de leer lineas y para cada linea releer todo el archivo tambien.

Para diferenciar los paquetes enviados de los recibidos hay algun campo que te permita diferenciarlos? (es decir, algun campo de la linea es del tipo 'e'-enviado y 'r'-recibido?). O solo puedes saber que un paquete ha sido recibido quando se repite un identificador de nodo (el primero siempre envia y en el segundo se recibe)? Dependiendo deberas hacerlo de una forma u otra, lo planteo con tu ejemplo:

Código:

+ 0.1 0 3 tcp 40 ------- 1 0.0 5.2 0 0
+ 0.5 0 3 tcp 50 ------- 2 0.0 6.2 0 0
r 0.130067 4 5 tcp 40 ------- 1 0.0 5.2 0 0

El '+' significa que es un paquete enviado y el 'r' significa que es un paquete recibido? Si es así en el ejemplo la primera linea significa envio, la segunda significa envio y la tercera recibo; suponiendo que el nodo es sexto campo, se confirma que se envia el paquete 1 desde 40 y se recibe el paquete 1 en 40, y se envia el paquete 2 desde 50 pero no se recibe en ningun sitio.

O por el contrario el '+' y el 'r' no tienen nada que ver y solo puedes saber el estado por pares de nodos donde la primera aparicion significa envio y la segunda recibo? Si es asi y suponiendo que el nodo es el sexto campo, la primera aparicion de 40 significa que se envia paquete 1 desde 40, y la segunda aparicion de 40 significa que se recibe ese paquete, la primera aparicion de 50 significa que se envia paquete 2, pero al no haber repeticion de 50 significa que ese paquete no llego a ningun sitio.

Te pregunto cual es el caso, porque la solucion es diferente en un caso y en otro.

vosk

[kelvi]

Te cuento:

Cojo un caso más fácil para explicar e intentaré detallar cada campo.

Código :

+ 0.4132 1 0 ack 40 ------- 1 1.0 0.0 0 1
 

+: significa que se a generado un paquete, este campo podria coger los siguientes valores

Código VALORES:

+: Generado o añadido a la cola.
r: Recibido.
d:Eliminado.
-: Enviado o quitado de la cola.
 

0.4132: Instante de tiempo en el qual a pasado este evento.

1: Nodo origen (No tiene porque ser el origen , pueden ser nodos intermedios)

0: Nodo destino (No tiene porque ser el destino , pueden ser nodos intermedios)

ack: Tipo de paquete.

40: Tamaño en bytes.

-------: Flags (no utilizados)

1: Número del flujo de datos

1.0: El 1 indica el origen (Este si que es el origen) el .0 no lo utilizo de momento.

0.0: El primer 0 indica el destino (Este si que es el destino) el .0 no lo utilizo de momento.

0: Nº secuencia del paquete especifico del mismo flujo.

1: Nº secuencia usado por el programa en general.

Ahora te muestro de donde saco los datos. Es un trozo de un fichero out.tr:

Código Out.tr:

+ 0.4132 1 0 ack 40 ------- 1 1.0 0.0 0 1
- 0.4132 1 0 ack 40 ------- 1 1.0 0.0 0 1
r 0.4264 1 0 ack 40 ------- 1 1.0 0.0 0 1
+ 0.4264 0 1 tcp 1040 ------- 1 0.0 1.0 1 2
- 0.4264 0 1 tcp 1040 ------- 1 0.0 1.0 1 2
+ 0.4264 0 1 tcp 1040 ------- 1 0.0 1.0 2 3
- 0.5096 0 1 tcp 1040 ------- 1 0.0 1.0 2 3
r 0.5196 0 1 tcp 1040 ------- 1 0.0 1.0 1 2
 

Este fichero consta de miles de lineas y por eso lo paso por un programa para filtrar-lo. Me deja las lineas que a mi me interesan en otro fichero llamado OutFiltrat.tr (Para ello utilizo el programa anterior que hicimos con un if que mira si los nodos que quiero y el flujo deseado coincide con el de la linea y la escribe en el fichero)(De ahí venia que no quería que el strtok() me machacara la linea).

Por ejemplo, si a mi me interesan los paquetes que van del nodo 1 al 0 y de flujo 0 pues este programa me seleccionaría las siguientes lineas:

Código OutFiltrat.tr:

+ 0.4132 1 0 ack 40 ------- 1 1.0 0.0 0 1
- 0.4132 1 0 ack 40 ------- 1 1.0 0.0 0 1
r 0.4264 1 0 ack 40 ------- 1 1.0 0.0 0 1
 

Una vez aquí lo que yo necesito es obtener datos. Por ejemplo, cuanto tarda un paquete a ir de un nodo a otro, cuanto tiempo se tarda entre generación de paquetes, cuantos paquetes han sido generados o recibidos, entre otras cosas... Por eso te comentaba lo de releer el fichero para ir comparando cada linea con las de el fichero y así poder ir tomando los datos que necesite cosa que me evita mucha faena si lo tuviera que hacer sobre papel.

Espero haberte aclarado algo más la situación. Estamos en contacto.
Fran

[kelvi]

Te incluyo también el código del programa de Filtrar por si te ayuda en algo:

Código C++:

#include <iostream>
#include <iomanip>
#include <fstream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <list>
#include <sstream>
 
using namespace std;
 
typedef struct {
    char EV;
    float T;
    int E,R;
    string P;
    float G;
    string FLA;
    int FLU;
    string O,D;
    float S,I;
} DADES_ARXIU;
 
enum ID_CAMPS{EV,T,E,R,P,G,FLA,FLU,O,D,S,I};
 
int main() {
    DADES_ARXIU camps;
    DADES_ARXIU zero = {0, 0, 0, 0, "", 0, "", 0, "", "", 0, 0};
    int camp;//incremental
    char *pch, *copia;
    string linia;
    //VARIABLES PER FILTRAR
    int em,re,fl;
    string ori,de;
    ostringstream convert,convert2;
    printf("EMISOR:");cin>>em;
    convert << em;
    ori=convert.str();
    ori = ori + ".0";
    printf("RECEPTOR:");cin>>re;
    convert2 << re;
    de=convert2.str();
    de = de + ".0";
    printf("FLUX:");cin>>fl;
 
    //FITXERS DE LECTURA I ESCRIPTURA   
    ifstream fitxer;
    ofstream fitxerFiltrat;
    fitxer.open("Proces/out.tr");
    fitxerFiltrat.open("Proces/outFiltrat.tr");
    if (!fitxer || !fitxerFiltrat) {
        cerr << "Error al llegir o Escriure fitxer";
        return 1;
    }
    while(getline(fitxer,linia)){
        copia = new char [linia.size()+1];
        strcpy (copia,linia.c_str());   
        camp = EV;
        pch = strtok(copia, " ");
        while(pch != NULL){
            switch(camp) {
                case EV: {                  
                                camps.EV = pch[0];
                        }break;
                case E: {
                    camps.E = atoi(pch);                    
                        }break;
                case R: {
                    camps.R = atoi(pch);                    
                }break;
                case FLU: {
                    camps.FLU = atoi(pch);       
                }break;
                case O: {
                    camps.O = pch;               
                        }break;
                case D: {
                    camps.D = pch;                   
                }break;
            }
            pch = strtok (NULL, " ");
            camp++;
        }
    if(camp != I+1){ cout << "ERROR DE FITXER DE LECTURA"; return 1;}
    if((camps.FLU==fl) && (ori.compare(camps.O)==0) && (de.compare(camps.D)==0) && (((camps.EV == '+') && (camps.E==em)) || ((camps.EV=='r')&&(camps.R==re)))){
        fitxerFiltrat << linia << endl;
    }
    //BUIDAR STRUCT
    memcpy(&camps, &zero, sizeof(DADES_ARXIU));
    //BUIDAR CHAR
    delete[] copia;
    }
    fitxer.close();
    fitxerFiltrat.close();
    return 0;
}
 

[vosk]

Creo que deberias crear 4 listas, una para cada tipo de notificacion ( + r d - ), de esta forma podras acotar las busquedas; primero parseas todo el archivo y distribuyes las filas en listas segun su caracter, luego p.ej. coges el primer elemento de la lista de añadidos y quieres buscar si ya ha llegado: pues vas a la lista de recibidos y solo recorres esa lista (omites los demas), y lo mismo para lo demas. De esta forma por ejemplo puedes trazar el recorrido de un paquete sabiendo que si esta en la lista de dispensados es que ya ha salido, eso significa que puede (o no) estar en la lista de recibidos, vas a la lista de recibidos y encuentras que ya ha sido recibido por un o mas nodos intermedios, sigues leyendo la lista de recibidos y encuentras que tambien fue recibido por el nodo final, eso significa que ya puedes quitar el paquete de la lista, pues vas a la lista de eliminados y buscas ese paquete: que está ahi pues bien se envio - recibio - finalizo el proceso, que no está pues bueno esperas el siguiente reporte. El codigo de filtro será el mismo pero distribuyendo las estructuras a la fila correspondiente; y el proceso de buscar será relativamente facil: si un paquete no ha salido no lo encontraras ni en recibidos ni el eliminados (no se, supongo), eso significa que solo tienes que procesar la lista de añadidos: para cada caso buscas las opciones que tiene.

Tambien tienes otra opcion que tal vez te acelere el proceso: bajate alguna libreria de bases de datos (SQLite es un manipulador de datos standalone que no necesita servidor ni instalacion, o si ya tienes servidor puedes mirar MySQL o cualquier otra que quieras). Parseas los datos de las lineas y los envias a la base de datos, y de ahi sacas las consultas que quieras: la parte de parseo de las lineas no afectará, pero en el momento de buscar colisiones (paquetes enviados y recibidos, o cualquier otra combinacion que quieras) seguramente será mucho mas rápida que cualquier cosa que puedas implementar en c (no digo que no sepas programar, pero a menos que seas programador de motores de bases de datos esas seguramente iran mejor por velocidad, control de errores, etc..)

Saludos
vosk

[kelvi]

Hola de nuevo,

He decidido eliminar los paquetes tipo '-' y tipo 'd' por lo que me deja solo dos listas '+' y 'r'. Los tipo '-' no me aportan nada y los 'd' solo necesito la cantidad la cual puedo sacar restando-le a los generados los recibidos.

Con el tema de la listas voy un poco perdido. Como podría recorrer-la? He visto que hay iteradores pero me pierdo en mi caso al tener el struct dentro de la lista. Sigo teniendo los campos separados igual que el struct? y si es así como puedo acceder a ellos para obtener los datos que necesito? Tendría que encontrar la manera de mover-me por las listas y así ir obteniendo los datos que necesito comparando las dos listas.

Te pongo el código para que veas como lo tengo ahora:

Código C++:

#include <iostream>
#include <iomanip>
#include <fstream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sstream>
#include <list>
 
using namespace std;
 
typedef struct {
    char EV;
    float T;
    int E,R;
    string P;
    float G;
    string FLA;
    int FLU;
    string O,D;
    float S,I;
} DADES_ARXIU;
 
enum ID_CAMPS{EV,T,E,R,P,G,FLA,FLU,O,D,S,I};
 
int main() {
    int Pgenerats=0,Prebuts=0,Peliminats=0;//DADES PER ANALITZAR
    int camp;//INDEX
    //ESTRUCTURES
    list <DADES_ARXIU> generats;
    list <DADES_ARXIU> rebuts;
    DADES_ARXIU camps;
    DADES_ARXIU zero = {0, 0, 0, 0, "", 0, "", 0, "", "", 0, 0};
    char *pch, *copia;
    string linia;
    //FITXER DE LECTURA 
    ifstream fitxer;
    fitxer.open("Proces/outFiltrat.tr");
    if (!fitxer) {
        cerr << "Error al llegir fitxer";
        return 1;
    }
 
    while(getline(fitxer,linia)){   
        copia = new char [linia.size()+1];
        strcpy (copia,linia.c_str());
        camp = EV;
        pch = strtok(copia, " ");
        while(pch != NULL){
            switch(camp) {
                case EV: {                  
                                camps.EV = pch[0];
                        }break;
                case T: {
                    camps.T = atof(pch);                    
                }break;
                case E: {
                    camps.E = atoi(pch);                    
                        }break;
                case R: {
                    camps.R = atoi(pch);                    
                }break;
                case P: {
                    camps.P = pch;                    
                        }break;
                case G: {
                    camps.G = atof(pch);                   
                }break;
                case FLA: {
                    camps.FLA = pch;                
                        }break;
                case FLU: {
                    camps.FLU = atoi(pch);       
                }break;
                case O: {
                    camps.O = pch;               
                        }break;
                case D: {
                    camps.D = pch;                   
                }break;
                case S: {
                    camps.S = atoi(pch);                    
                        }break;
                case I: {
                    camps.I = atoi(pch);                    
                }break;
            }
            pch = strtok (NULL, " ");
            camp++;
        }
    if(camp != I+1){ cout << "ERROR DE FITXER"; return 1;}
    if(camps.EV == '+'){Pgenerats++;generats.push_back (camps);}
    if(camps.EV == 'r'){Prebuts++;rebuts.push_back (camps);}
    //BUIDAR STRUCT
    memcpy(&camps, &zero, sizeof(DADES_ARXIU));
    //BUIDAR CHAR
    delete[] copia;
    }
    while (!generats.empty()){
    //AQUI TENDRIA QUE COGER UNA LINEA Y BUSCAR LA RECIBIDA EN LA OTRA LISTA
    generats.pop_front();
    }
    Peliminats=Pgenerats-Prebuts;
        fitxer.close();
    generats.clear();
    rebuts.clear();
    return 0;
}
 

Fran

[vosk]

El tema de listas es cuestion de estar un rato delante practicando; para recorrer la lista generados (este bucle reemplaza el que tienes en la linea 99 while (!generats.empty()){...)

Código:

list <DADES_ARXIU>::iterator itr_generats;
for(itr_generats = generats.begin(); itr_generats != generats.end(); itr_generats++) {
    //printf("T=%f", (*itr_generats).T);//ejemplo para acceder al dato T
}

Lo que te interesa: itr_generats son iteradores de elementos de la lista, en este caso son posiciones de structs DADES_ARXIU ubicadas en 'generats'. Si usaras tipos de datos en vez de structs, el propio iterador puede comportarse como el tipo que representa, pero al usar structs tienes que desreferenciar el iterador para que se comporte como la struct, por eso haces lo de (*itr_generats).T para acceder al elemento T que está dentro del struct DADES_ARXIU que esta guardado en la lista 'generats' y que está siendo apuntado por 'itr_generats'. Si en vez de una lista se structs tuvieras una lista de punteros a structs (no es tu caso, solo completo la explicacion) tendrias que desreferenciar igualmente el iterador y luego aplicar el puntero dentro de referencias a structs (*itr_generats)->T ok? En cualquier caso, tanto si usas structs como si usas tipos 'normales' (enteros o lo que sea), la desreferenciacion del iterador se comporta como el tipo de dato esperado.

Y ahora lo que te interesa mas aun: como buscas dentro de la otra lista algun tipo de colision? Dos formas, o recorres la otra lista hasta dar con lo que buscas, o usas alguna funcion de c++ que te permita hacer comparaciones (lo siguiente lo digo de memoria, deberias consultarlo: las funciones find, find_if, search y tal vez otra te podran servir, no se si todas sirven para trabajar con iteradores de struct).

Con otro iterador, y por ejemplo si quieres encontrar los recibidos que coinciden en O y D con los generados, haras algo asi:

Código:

list <DADES_ARXIU>::iterator itr_generats;
list <DADES_ARXIU>::iterator itr_rebuts;

for(itr_generats = generats.begin(); itr_generats != generats.end(); itr_generats++) {
    for(itr_rebuts = rebuts.begin(); itr_rebuts != rebuts.end(); itr_rebuts++) {
        if(((*itr_generats).O == (*itr_rebuts).O) && ((*itr_generats).D == (*itr_rebuts).D)) {
            //ya lo tienes
        }
    }
}

(tal vez en el caso de O y D que son strings no sea esta la mejor forma de hacer la comparacion, pero como ejemplo ya sirve)

Ten en cuenta que en un archivo que resulta gg generados y rr recibidos se haran un total de gg * rr comprovaciones; si las comprovaciones solo requieren encontrar la primera colision asegurate de salir del bucle interno enseguida para minimizar el tiempo de ejecucion.

vosk

[kelvi]

Hola vosk,

Al final descubrí un lenguaje con linux AWK que es específico para leer archivos que están separados por campos. Es mucho más rápido y fácil de hacer.

http://www.ns2ultimate.com/post/3995318343/post-processing-ns2-result-using-ns2-trace-main-post

Igualmente muchas gracias por tu atención. Has sido muy amable.

Saludos,
Fran