Hallo!

Den ganzen Nachmittag habe ich damit verbracht, daß ich via Serialize Zeichen einlese, eine andere Funktion aufrufe, die diese verarbeitet und dann an View::OnDraw weitergibt.

Und was ist das Ergebnis? Ich werfe den Schrott gleich aus dem Fenster!

Meine Codes sehen so aus:

c++:

void CLadenSpeichernDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
// ZU ERLEDIGEN: Hier Code zum Speichern einfügen
}
else
{
// ZU ERLEDIGEN: Hier Code zum Laden einfügen
ar >> m_c_Zeichen;
CDateiZugriff::Lesen();
}
}
--------------------------------------------
void CDateiZugriff::Lesen()
{
//AfxMessageBox("Tach!");
m_s_Zeile += m_c_Zeichen;
}


Fehlermeldung:
My Projects\LadenSpeichern\DateiZugriff.cpp(32) : error C2597: Ungueltige Referenz auf ein Datenelement 'CDateiZugriff::m_s_Zeile' in einer statischen Member-Funktion


Die Variablen sind:

char m_c_Zeichen und CString m_s_Zeile in beiden Klassen als public deklariert

Wer hat eine Ahnung, was ich falsch mache, weil eigendlich will meinen Compi nicht aus den Fensterwerfen, aber wer nicht höhren will, der muß fühlen!

THX Markus

So wie es ausschaut versuchst du in einer statischen Funktion auf eine Objektvariable zuzgreifen. Da statische Funktionen unabhängig von Objekten
existieren und nicht statische Memebrvariablen von der existenz eines
Objektes abhängig sind geht das natürlich nicht und der Compiler meldet
dir einen Fehler.

Ich gehe mal von deinem Code aus das void CDateiZugriff::Lesen() als statische
Memberfunktion deiner Klasse deklariert ist
Wenn void CDateiZugriff::Lesen() unbedingt statisch sein muss wirsrt du wohl nicht drumrumkommen, die Membervariablen m_s_Zeile, m_c_Zeichen auch als statisch
zu deklarieren, wenn du dies beabsichtigst...


Gruß

RedWing

Hi Redwing!

Vielen Dank für deine schnelle Antwort!

Ich werden mal schauen, ob die Fkt. statisch ist.

So!


Die Fkt. war als static deklariert, welches ich entfernt habe.

Aber nun taucht die fehlermeldung auf:

:\My Projects\LadenSpeichern\LadenSpeichernDoc.cpp(68) : error C2352: 'CDateiZugriff::Lesen' : Unzulaessiger Aufruf einer nichtstatischen Member-Funktion
h:\my projects\ladenspeichern\dateizugriff.h(17) : Siehe Deklaration von 'Lesen'

Und hier kommt sie her:

void CLadenSpeichernDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
// ZU ERLEDIGEN: Hier Code zum Speichern einfügen
}
else
{
// ZU ERLEDIGEN: Hier Code zum Laden einfügen
ar >> m_c_Zeichen;
CDateiZugriff::Lesen(); <<<<<----FEHLER!
}
}
Ich will hier nur die Fkt. CDateiZugriff aufrufen!

Ja das liegt daran das du jetzt um die Funktion aufzurufen
ein Objekt vom Typ der Funktion brauchst, und nicht mehr den Klassennamen
für den Aufruf verwenden kannst....
Es gibt zwei Möglichkeiten:

1.) Du machst die Funktion lese nicht statisch und übergibst der
Funktion CLadenSpeichernDoc::Serialize(CArchive& ar) ein Objekt vom
Typ CDateiZugriff damit du mit Hilfe dieses Objekts auf die Funktion lese
draufzugreifen kannst oder:
2.) Du lässt die Funktion lese statisch und machst zusätzlich die Membervariablen
die die Funktion benutzt auch statisch...


Gruß

RedWing

zu1.


Meinst du etwas wie: CDateiZugriff::Serialize(ar);

Ich hab nicht so die Ahnung

nein das funktioniert nicht!

Ich habe jetzt mal die beiden Varialblen auf static gesetzt. Aber da kamen nur neue Fehlermeldungen mit vielen @'s.

Hallo!

Falls noch nichts aus dem Fenster geflogen ist schlag ich mal fogendes vor:

1) alle static's aus dem Code entfernen (machen gerade bei "Nicht Berufs Progra's" Probleme)

2) Die Klassen sind unabhängig voneinander und wissen erstmal nichts voneinander.
Dann werden bei der lese Funktion nicht die Daten in der Klasse CLadenSpeichernDoc geändert sondern nur in CDateiZugriff. Zumindest wenn vorher ein Objekt angelegt wurde (Ursprünglich nicht gemacht -> Fehler da die Variablen noch nicht exestieren - Speicherzugriff)

3) Bei mir würde sowas folgend aussehen:
Headerfiles

LadenSpeichernDoc.h
"
"mach was noch so soll
"
#include "DateiZugriff.h"
"
"mach was noch so soll
"

class CLadenSpeichernDoc
{
public:
char m_c_Zeichen;
CString m_s_Zeile;
void Serialize(CArchive& ar) ;
}

DateiZugriff.h
"
"mach was noch so soll
"
class CDateiZugriffDoc
{
public:

CString Zeile;//umbenannt damit der Unterschied klar wird
virtual BOOL PreTranslateMessage(MSG* pMsg);//vom Assi hinzufügen lassen

}

extern CDateizugriffDoc cdd;// irgendwo auf der Welt gibt es ein globales Objekt


Änderungen in den CPP's
DateiZugriff.cpp
#include "DateiZugriff.h"

1) alle statics weg
2) statt Lese()
BOOL CDateiZugriff::PreTranslateMessage(MSG* pMsg)
{
// TODO: Speziellen Code hier einfügen und/oder Basisklasse aufrufen
//pMsg auslesen und in Zeile speichern;
//MSDN hilft
return CDialog::PreTranslateMessage(pMsg);
}
3) unten folgendes anlegen:
CDateizugriffDoc cdd; //global!

LadenSpeichernDoc.cpp

#include "LadenSpeichernDoc.h"

void CLadenSpeichernDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
// ZU ERLEDIGEN: Hier Code zum Speichern einfügen
}
else
{
// ZU ERLEDIGEN: Hier Code zum Laden einfügen
ar >> m_c_Zeichen; //komm eher aus der C-Welt und bin mir hier nicht ganz sicher m_c_Zeichen mit Inhaltvon ar füllen;
m_s_Zeile += cdd.Zeile;//aktuelles von globalem Objekt auslesen und in eigener Variablen speichern
cdd.Zeile.Empty();//Inhalt löschen, damit nichts doppelt gelesen wird

}
}
Das sollte jetzt eigentlich weiter helfen und die Warnungen beseitigen... Zumindest wenn keine Schreibfehler mehr drin sind.

Gruß Michael

Hi Michale!


Autsch

Das muß ich mir erst einmal auf der Zunge zergehen lassen!

Ich melde mich, sobald ich alles ausprobiert habe.

Soweit allerbesten Dank!

Markus

Hi Michael!


Natürlich bin zu beschränkt, um diese ausführliche Anleitung problemlos umsetzen zu können. Sollte vieleicht doch Bäcker werden))

Die Klasse class CDateiZugriffDoc gibt es - soweit ich weiß - nicht, sondern nur CDateiZugriff. Ist das richtig, daß du CDateiZugriffDoc meinst? Wenn ja, kann ich damit nichts anfangen. ((

Weiterhin:

extern CDateizugriffDoc cdd;// irgendwo auf der Welt gibt es ein globales Objekt

Die Zeile habe ich am Ende der *.h nach der geschweiften Klammer zu und vor dem endif gesetzt. Auch hier CDateizugriffDoc

Die Variable m_c_Zeichen ganz normal als public deklarieren?

Gruß Markus

Hi mstank,

so wie es aussieht, willst du von einer Datei etwas einlesen.
Da du dies in Serialize machst, dient diese Datei der Persistance deines Dokuments.
Das heisst, wenn du ein Dokument öffnest, wird diese Datei gelesen und dein Dokument damit aufgebaut.
Das Archiv liefert dir einen Strom von Daten in der Reihenfolge wie er geschrieben wurde. Beim Laden und beim Speichern musst du dieselben Attribute lesen/schreiben und in der richtigen Reihenfolge, damit alle Daten den entsprechenden Variablen zugeordnet werden.
Soviel zum Serialisieren eines Dokuments.

Du willst anscheinend das Lesen über eine extra Klasse erledigen, bzw. nicht das Lesen selbst, sondern das Zusammenbauen einer Zeile.
Das über globale Variablen zu erledigen ist nicht sehr schön.

Code :

1 2	ar >> m_c_Zeichen; CDateiZugriff::Lesen();

Du solltest, wenn du es schon über eine extra Klasse machst, die in keinem Zusammenhang mit dem Dokument steht, so erledigen, dass die gelesene Variable an diese extra Klasse übergeben wird.

Code :

1 2 3

char c; ar >> c; CDateiZugriff::Lesen(c);

Auf jeden Fall solltest du dir überllegen, ob das was du da tust, wirklich das ist, was du tun wolltest.

Gruss
Dora