C++ - Classes em memoria secundaria

[eddie_gordo]

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...

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..

 

[HecKel]

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

 

[moo]

Podes procurar mais sobre seriação de objectos no google, mas deixo aqui umas ligações para começar:
http://www.functionx.com/cpp/articles/serialization.htm
http://www.informit.com/...
Se quiseres algo mais completo, existem inúmeras bibliotecas que fornecem essa funcionalidade como, por exemplo, a boost:
http://www.boost.org/libs/serialization/doc/index.html

 

[jahred]

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

 

[eddie_gordo]

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...

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..! Bou tiraree 20!!! ou nao! lol Aquele abraxo


Cumprimentos para os outros

 

[moo]

Pode ser que o seguinte código te ajude. Imagina que tens uma estrutura xpto que queres guardar para ficheiro:

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:

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:

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:

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:

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:

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:

#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.

 

[eddie_gordo]

Obrigado a todos pelas ajudas! Já entreguei o trabalho... 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!

Cumprimentos a todos!