🚀 go-pugleaf

ro@gigabase.rhein-main.de (Ralf Oberhoffner) wrote:
>Hallo Alle
>
>Ich schreibe gerade an eine Prog. und muss dazu Files auslesen und schreiben,
>nun waehre es sehr hilfreich wenn ich direkt vom file in ein struct einlesen
>koennte bzw. ein struct in eine Datei schreiben koennte, ich habe schon viel
>ausprobiert aber es ging alles nicht.


Probier's mal mit:
------------------

FILE *fp;
struct XYSTRUCT xy_s;

fp = fopen("blah.dat","rb");
fread(&xy_s,sizeof(XYSTRUCT),number_of_structs,fp);
fclose(fp);

--
Markus Becker
Dipl.-Ing.
Zentrum fuer Sensorsysteme (ZESS)

email:	becker@zess.uni-siegen.de
http://www.zess.uni-siegen.de/
http://www.zess.uni-siegen.de/private/becker/
http://www.zess.uni-siegen.de/private/becker/win95

Markus Becker <becker@zess.uni-siegen.de> writes:

>> Ich schreibe gerade an eine Prog. und muss dazu Files auslesen und schreiben,
>> nun waehre es sehr hilfreich wenn ich direkt vom file in ein struct einlesen
>> koennte bzw. ein struct in eine Datei schreiben koennte, ich habe schon viel
>> ausprobiert aber es ging alles nicht.


> Probier's mal mit:
> ------------------

> FILE *fp;
> struct XYSTRUCT xy_s;

> fp = fopen("blah.dat","rb");
> fread(&xy_s,sizeof(XYSTRUCT),number_of_structs,fp);
> fclose(fp);

Das ist die C-Lösung.  In C++ würde man für sowas wohl eher
fstreams und istream::read / ostream::write verwenden.

Ganz davon abgesehen wäre es aus Portablilitätsgründen sowieso besser,
textuelle Darstellung oder zumindest eine plattformunabhängige
Kodierung wie XDR zu verwenden.

Harald Fuchs (hf@colibri.de) wrote:
>  Markus Becker <becker@zess.uni-siegen.de> writes:

>  >> Ich schreibe gerade an eine Prog. und muss dazu Files auslesen und schreiben,
>  >> nun waehre es sehr hilfreich wenn ich direkt vom file in ein struct einlesen
>  >> koennte bzw. ein struct in eine Datei schreiben koennte, ich habe schon viel
>  >> ausprobiert aber es ging alles nicht.


>  > Probier's mal mit:
>  > ------------------

>  > FILE *fp;
>  > struct XYSTRUCT xy_s;

>  > fp = fopen("blah.dat","rb");
>  > fread(&xy_s,sizeof(XYSTRUCT),number_of_structs,fp);
>  > fclose(fp);

>  Das ist die C-Lösung.  In C++ würde man für sowas wohl eher
>  fstreams und istream::read / ostream::write verwenden.

>  Ganz davon abgesehen wäre es aus Portablilitätsgründen sowieso besser,
>  textuelle Darstellung oder zumindest eine plattformunabhängige
>  Kodierung wie XDR zu verwenden.

Von der Methode ist im allgemeinen ganz abzuraten. Abgesehen von den
Portabilitaetsprblemen funktioniert sie nur bei einfachen Groessen und
den allereinfachsten Datenstrukturen. Sind Zeiger oder Referenzen im 
Objekt enthalten, muss man sich etwas mehr einfallen lassen. Enthaelt 
die Klasse virtuelle Funktionen, gibt es mit groesster Wahrscheinlichkeit 
eine Katastrophe.

Zeichenweise Ein-/Ausgabe und Ueberladen von operator<<() bzw. operator>>()
ist i.a. die vernuenftigste Methode.

Gruss
	Bernd
--
+----------------------------------+
|          Bernd Eggink            |
|    Rechenzentrum Uni Hamburg     |
| admin@rzaix13.rrz.uni-hamburg.de |
+----------------------------------+

In <039_9510102206@gigabase.rhein-main.de> ro@gigabase.rhein-main.de (Ralf Oberhoffner) writes:

>Hallo Alle

>Ich schreibe gerade an eine Prog. und muss dazu Files auslesen und schreiben,
>nun waehre es sehr hilfreich wenn ich direkt vom file in ein struct einlesen
>koennte bzw. ein struct in eine Datei schreiben koennte, ich habe schon viel
>ausprobiert aber es ging alles nicht.

>Gruss
>Ralf

struct bla
{
	int foo;
	char fasel;
	long joi;

	void save(ofstream &ausgabedatei);
	void load(ifstream &eingabedatei);
}

void bla::save(ofstream &ausgabedatei)
{
	ausgabedatei << foo << fasel << joi;
}

void bla::load(ifstream &eingabedatei)
{
	eingabedatei >> foo >> fasel >> joi;
}

/* alles klar?

		Gruss, Benni */
-- 
benni@informatik.uni-frankfurt.de|http://www.uni-frankfurt.de/gnomic/hello.html
    "Deshalb, Leute, die glauben, dass Computer werden nicht koennen, wie
      Menschen zu denken, auch glaubt nicht in Maschine-Uebersetzung."

wolfgang@wmsickte.escape.de (Wolfgang Muees) writes:

> hf@colibri.de wrote:
>> 
>> Ganz davon abgesehen wäre es aus Portablilitätsgründen sowieso besser,
>> textuelle Darstellung oder zumindest eine plattformunabhängige
>> Kodierung wie XDR zu verwenden.

> Hey!

Nu schrei doch nicht gleich so, ich bin ja schon wach...

> was ist XDR?

Ein von SUN entwickeltes Verfahren zur Kodierung binärer Daten, das
sich auch auf vielen anderen Unixen verbreitet hat.  Der Vorteil
gegenüber der textuellen Kodierung ist die kompaktere Darstellung und
die Zeitersparnis beim Kodieren/Dekodieren.  Wenn beides nicht so
kritisch ist, würde ich allerdings auch die textuelle Darstellung
vorziehen.

> wolfgang@wmsickte.escape.de (Wolfgang Muees) writes:
>
> > hf@colibri.de wrote:
> >>
> >> Ganz davon abgesehen wäre es aus Portablilitätsgründen sowieso besser,
> >> textuelle Darstellung oder zumindest eine plattformunabhängige
> >> Kodierung wie XDR zu verwenden.
>
> > Hey!
>
> Nu schrei doch nicht gleich so, ich bin ja schon wach...
>
> > was ist XDR?
>
> Ein von SUN entwickeltes Verfahren zur Kodierung binärer Daten, das
> sich auch auf vielen anderen Unixen verbreitet hat.  Der Vorteil
> gegenüber der textuellen Kodierung ist die kompaktere Darstellung und
> die Zeitersparnis beim Kodieren/Dekodieren.  Wenn beides nicht so
> kritisch ist, würde ich allerdings auch die textuelle Darstellung
> vorziehen.

Danke schoen.

Du hast nicht zufaellig die Definition da?

MFG
Wolfgang


--------------------------------------------------------------
> wolfgang@wmsickte.escape.de | Wolfgang Muees  +49-5305-685 <
>                             | Am Hohlweg 5, D-38173 Sickte <
--------------------------------------------------------------
## CrossPoint v3.02 ##

On 12 Oct 1995 00:58:07 GMT,
benni@hera.rbi.informatik.uni-frankfurt.de (Benjamin Baermann) wrote:

>struct bla
>{
>	int foo;
>	char fasel;
>	long joi;

>	void save(ofstream &ausgabedatei);
>	void load(ifstream &eingabedatei);
>}

>void bla::save(ofstream &ausgabedatei)
>{
>	ausgabedatei << foo << fasel << joi;
>}

>void bla::load(ifstream &eingabedatei)
>{
>	eingabedatei >> foo >> fasel >> joi;
>}


Hm, und was passiert, wenn beim Speichern fasel=='0' oder eine
sonstige ASCII-Ziffer ist? Dann packt load() den ganzen Schlamassel
nach foo  :-(

void bla::save(ofstream &ausgabedatei)
{
	ausgabedatei << foo << ' ' << fasel << ' ' << joi;
}

So ist's zwar ein bisschen besser, allerdings nur solange, bis fasel
beim Speichern ein Leerzeichen ist...

Also, noch jemand mit 'nem besseren Vorschlag?

Tschuess...
		Michael


[Posted with Free Agent 1.0. For info, email agent-info@forteinc.com.]

In <45s6e2$dvj@h20-hrze.uni-duisburg.de> mauch@uni-duisburg.de (Michael Mauch) writes:

>On 12 Oct 1995 00:58:07 GMT,
>benni@hera.rbi.informatik.uni-frankfurt.de (Benjamin Baermann) wrote:

>Hm, und was passiert, wenn beim Speichern fasel=='0' oder eine
>sonstige ASCII-Ziffer ist? Dann packt load() den ganzen Schlamassel
>nach foo  :-(

>void bla::save(ofstream &ausgabedatei)
>{
>	ausgabedatei << foo << ' ' << fasel << ' ' << joi;
>}

>So ist's zwar ein bisschen besser, allerdings nur solange, bis fasel
>beim Speichern ein Leerzeichen ist...

Da hast Du natuerlich Recht. Das hab ich uebersehen. Aber irgendein
Trennzeichen braucht man halt immer, wenn man in ASCII daten abspeichert
und wieder einliest.

>Also, noch jemand mit 'nem besseren Vorschlag?

Wurde hier ja schon gesagt, diese SUN-DBA, deren Namen mir entfallen
ist. Damit kann man wohl direkt Binaerzeugs abspeichern. In den meisten
Faellen finde ich aber eine ASCII-Abspeicherung sinnvoller, da man dann
die Daten auch als Mensch noch vernuenftig manipulieren kann, etc. Was
ja zum testen manchmal ganz sinnvoll ist. 

Wenn man andere Trennzeichen verwendet muesste man irgendwie ganze
Zeilen einlesen und dann einen regulaeren Ausdruck drueberlaufen lassen.
Geht z.B. mit der g++-Stringklasse.

>Tschuess...
>		Michael

Gruesse, Benni
-- 
benni@informatik.uni-frankfurt.de|http://www.uni-frankfurt.de/gnomic/hello.html
    "Deshalb, Leute, die glauben, dass Computer werden nicht koennen, wie
      Menschen zu denken, auch glaubt nicht in Maschine-Uebersetzung."