1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

C++ - Classes em memoria secundaria

Discussão em 'Programação' iniciada por eddie_gordo, 4 de Junho de 2006. (Respostas: 6; Visualizações: 1248)

  1. eddie_gordo

    eddie_gordo Power Member

    Boas...

    Estou a fazer um trabalho em C++, simulando o funcionamento de uma linha do Metro. O enunciado pode ser visto aqui: http://www.dei.isep.ipp.pt/~cneves/TLP1_0506_2/Metro.htm

    Como é obvio, nao vou pedir que me façam o trabalho todo... :P

    Já tenho praticamente tudo implementado, a unica coisa que me está a dar a volta à cabeça é a forma como vou conseguir guardar todas as classes, listas e listas dentro de classes e por aí, em memória secundária...

    Alguém pode dar umas luzinhas em como fazer isto? ;) Se for necessário colocar aqui algum código avisem, sff...

    Cumprimentos e obrigado desde ja pela disponibilidade.. :)
     
  2. HecKel

    HecKel The WORM

    Boas!

    Sinceramente não sei se o C++ tem suporte de serilização..., e o google também não me ajudou a obter a resposta..., mas a minha sugestão é criares uma função que irá escrever para um ficheiro todo o conteúdo de uma classe organizado de uma forma à tua escolha..., mas atenção para os apontadores..., quando fores ler o ficheiro tens de "reconstruir" novamente as estruturas com base no que gravaste para o ficheiro..., tal como os respectivos apontadores...

    Se gravares a referência do apontador acredita que isso vai dar buraco, pois essa referência é uma referência em memória que muito provavelmente irá mudar numa outra utilização do programa, portanto arranja uma estratégia para isso :)

    abraços, HecKel
     
  3. moo

    moo

  4. jahred

    jahred Power Member

    Ó João, a ajuda que eu te posso dar é apoio moral.... lol.... já foste... eskece esse trabalho... lol
     
  5. eddie_gordo

    eddie_gordo Power Member

    Antes de mais, obrigado a todos pelas ajudas... Seriaçao está um pouco fora de questão, pois já é um pouco avançado para aquilo que dei até agora... :P

    Penso que vou ter que guardar as informaçoes todas que tenho nas listas para um ficheiro de texto, e quando for ler do ficheiro, terei que as recriar... nao? ;)



    jahred, malukee..! :P Bou tiraree 20!!! ou nao! lol Aquele abraxo


    Cumprimentos para os outros
     
  6. moo

    moo

    Pode ser que o seguinte código te ajude. Imagina que tens uma estrutura xpto que queres guardar para ficheiro:
    Código:
    struct xpto
    {
    	xpto() { }
    	xpto(int f1, int f2) : field1(f1), field2(f2) { }
    
    	int field1;
    	int field2;
    };
    
    Como tens listas de xpto, tens algo como o seguinte:
    Código:
    int main()
    {
    	list<xpto> out;
    	list<xpto> in;
    	for (int i = 0; i != 10; ++i)
    	{
    		out.push_back(xpto(i, i + 1));
    	}
    
    	cout << "out" << endl;
    	show(out);
    	serialize(out);
    
    	cout << "in" << endl;
    	deserialize(in);
    	show(in);	
    }
    
    Ou seja, tens uma lista "out" com vários objectos e queres guardar essa lista para um ficheiro - serialize(out). Mais tarde queres ler o conteúdo do ficheiro - deserialize(in) - para a lista "in". As duas listas devem ter elementos equivalentes e, neste exemplo, poderemos confirmar isso com o show.

    O serialize é isto:
    Código:
    void serialize(list<xpto>& data)
    {
    	ofstream file("data.txt");
    
    	for (list<xpto>::const_iterator i = data.begin();
    		i != data.end();
    		++i)
    	{
    		file << *i << endl;
    	}
    	
    	file.close();
    }
    
    Que não é mais que percorrer toda a lista e inserir cada elemento no ficheiro.

    E o deserialize é isto:
    Código:
    void deserialize(list<xpto>& data)
    {
    	ifstream file("data.txt");
    	
    	while (file)
    	{
    		xpto x;
    		file >> x;
    		if (!file.fail())
    		{
    			data.push_back(x);
    		}
    	}
    
    	file.close();
    }
    
    De notar que estão a ser utilizados os operadores de inserção e extracção para objectos do tipo xpto. Isto acontece porque foram definidos as seguintes funções:
    Código:
    istream& operator>> (istream& in, xpto& x)
    {
    	return (in >> x.field1 >> x.field2);
    }
    
    ostream& operator<< (ostream& out, const xpto& x)
    {
    	return (out << x.field1 << ' ' << x.field2);
    }
    
    Já agora deixo aqui o show:
    Código:
    void show(list<xpto>& data)
    {
    	for (list<xpto>::const_iterator i = data.begin();
    		i != data.end();
    		++i)
    	{
    		cout << i->field1 << ' ' << i->field2 << endl;
    	}
    	
    }
    
    E não esquecer os includes:
    Código:
    #include <iostream>
    #include <list>
    #include <fstream>
    
    using namespace std;
    
    Podes ver o conteúdo do ficheiro com os dados, data.txt. É um ficheiro de texto normal.
     
  7. eddie_gordo

    eddie_gordo Power Member

    Obrigado a todos pelas ajudas! Já entreguei o trabalho... :P Nao usei serialização, apenas fui lendo os valores q tinha nos atributos das classes e gravando para um ficheiro de texto, separados por um caracter à escolha (usei o '#')... Dps, para ler novamente, foi só usar a função strtok da libraria string.h para poder ir buscar campo a campo e atribuir novamente os valores aos atributos das classes! :P :P

    Cumprimentos a todos!
     

Partilhar esta Página