Hi, On Thu, 10 Oct 2002, Christian Weickhmann wrote:

Das ist vielleicht nicht so ganz rübergekommen (OK, ich habe es ja nicht richtig hingeschrieben...): Genau dieser Typecast führt zu Müll!

Kann nicht sein ;-) Gib einen vollstaendigen Sourcecode (aber bitte < 100 Zeilen), der dies tut.

unsigned char* irgendwas = "Blablabla"; strcpy(zielString, (const char*)irgendwas);

aufrufe steht da Müll!

Ist "zielString" denn nun alloziert oder nicht?

Beim Ausdrucken fällt das erst richtig auf:

unsigned char* irgendwas = "Blabla"; printf("%s", irgendwas); // Funktioniert hier interessanterweise // ohne &

Klar. &irgendwas haette ja Typ "unsigned char **" (die Addresse eines Pointers hat eben Typ Pointer of Pointer), und das wuerde sicherlich, wenn interpretiert als String ("%s"), lustige Hexzeichen ausgeben.

printf("%s", (char*)irgendwas);

Das funktioniert definitiv so. Wenn es das nicht tat, dann war entweder "irgendwas" nicht initialisiert, oder du hattest nicht genau die obige Zeile geschrieben.

Ich kann's leider nicht reproduzieren, weil ich die Stelle im Code bereits geändert habe. Jedenfalls kommt bei einem Typecast eben nicht der richtige Inhalt raus...

Doch.

Klasse sm_schueler speichert die Daten einer Person (eines Schülers) und stellt Funktionen zu deren Manipulation bereit. Will ich jetzt ein Array von solchen Objekten erzeugen, kann es dann der Grund für dieses SIGSEGV sein, dass ich folgendes gemacht habe:

sm_schueler *s[100]; // um 100 Elemente von sm_schueler zu initialisieren...

Ehm. Das initialisiert ueberhaupt nix. Du scheinst verwirrt zu sein bezueglich Objektinstanzen und Pointer auf Objektinstanzen. Obiges reserviert Speicher fuer 100 _Pointer_ auf sm_schueler Instanzen. Wenn es ne globale Var ist, dann sind alle diese Pointer nach Programmstart NULL-initialisert, wenn's ne lokale Variable ist, steht einfach Muell drin (liegt eben auf dem Stack).

dann der Aufruf:

s[0]->setName("EinName");

Hast du jemals s[0] irgendwas zugewiesen, wie z.B. "s[0]=new sm_schueler;" Wenn nicht, dann ist s[0] immer noch 0, womit wir also effektiv den Aufruf 0->setName(...) haben, was natuerlich ebenfalls ne SEGV produziert, da der this pointer dann NULL ist.

Ist das so korrekt oder muss ich s[0] vorher noch initialisieren? Wenn ja, wie?

Naja, du musst eben Instanzen dieser sm_schueler Klasse anlegen, du hast ja explizit bloss pointer darauf reserviert. Wenn du gleich beim Programmstart den Speicher fuer diese Instanzen reservieren willst (im Gegensatz dynamisch zur Laufzeit), so musst du s so schreiben: sm_schueler s[100]; Das reserviert 100 Instanzen von sm_schueler, und 0-initialisiert sie (wenn s file-global ist). Aufrufe von Methoden auf diesen Objekten nutzen dann natuerlich nicht den -> operator, sondern: s[0].setName(...); Man beachte, das dann s[0] eben nicht mehr die _Addresse_ eines Objektes ist, sondern das Objekt selbst. Die Address von ihm ist &s[0]. Ciao, Micha.

Hallo Ralf! Um gleich mal alle Unklarheiten zu beseitigen: Zum System: - gcc-2.95 - libxml2 (v 2.4.23) Mein Code sieht folgendermaßen aus: // --------------------- // schueler.h class sm_schueler { private: static int anzahl; // Es steht noch nicht fest, ob ich das brauche, also // nicht wichtig. char *name, *vorname; int schuljahr; // Welche Klasse und welches Halbjahr public: sm_schueler(); ~sm_schueler(); char* getName(); char* getVorname(); int getSchuljahr(); void setName(const unsigned char*); void setVorname(const unsigned char*); void setSchuljahr(int); }; // --------------------- // schueler.cpp #include "schueler.h" sm_schueler::sm_schueler() {anzahl++;} sm_schueler::~sm_schueler() {anzahl--;} char* sm_schueler::getName() {return name;} char* sm_schueler::getVorname() {return vorname;} int sm_schueler::getSchuljahr() {return schuljahr;} void sm_schueler::setName(const unsigned char* n) { strcpy(name, (char*)n); } void sm_schueler::setVorname(const unsigned char* vn) { strcpy(name, (char*)vn); } void sm_schueler::setSchuljahr(int s) {schuljahr = s;} // ---------------------- // dateihandler.h #include #include #include #include "schueler.h" class dateihandler { public: dateihandler(); ~dateihandler(); dateihandler(char*, sm_schueler*); void oeffne(char*); private: xmlDocPtr doc; xmlNodePtr root, sdaten; void getXMLschueler(char*, sm_schueler*); int parseSchuljahr(const unsigned char*); }; // ---------------------- // dateihandler.cpp #include "dateihandler.h" dateihandler::dateihandler() { } dateihandler::dateihandler(char* dateiname, sm_schueler* s) { oeffne(dateiname); getXMLschueler(dateiname, s); } dateihandler::~dateihandler(){ } /** No descriptions */ void dateihandler::getXMLschueler(char* dateiname, sm_schueler* s){ int i=0; if(!doc->root || xmlStrcmp(doc->root->name, (const xmlChar*) "schuelerdaten")) { fprintf(stderr, "\nFehler\n%s", dateiname); return; } sdaten = doc->root->xmlChildrenNode->xmlChildrenNode; while(sdaten != NULL) { s[i].setName(xmlGetProp(sdaten, (const xmlChar*)"name")); s[i].setVorname(xmlGetProp(sdaten, (const xmlChar*)"vorname")); s[i].setSchuljahr(parseSchuljahr(xmlGetProp(sdaten, (const xmlChar*)"schuljahr"))); char *name = s->getName(); char *vorname = s->getVorname(); int schuljahr = s->getSchuljahr(); fprintf(stderr, "%d %s, %s [.] : %d\n", nummer, *name, *vorname, schuljahr); // Hier verreckt das Programm zur Laufzeit. Ich weiß aber leider nicht, // woran es liegt. Laut backtrace (KDE-Crashmanager) liegt der Fehler aber // in fprintf() ... // Dazu unten mehr. sdaten = sdaten->next; } } void dateihandler::oeffne(char* dateiname){ doc = xmlParseFile(dateiname); if (doc == NULL) { fprintf(stderr, "Die Datei %s konnte nicht geöffnet werden.", &dateiname); xmlFreeDoc(doc); return; } root = xmlDocGetRootElement(doc); if (root == NULL) { fprintf(stderr, "Datei leer oder nicht XML-formatiert. %s", &dateiname); } } int dateihandler::parseSchuljahr(const unsigned char* s){ int parsed; switch((char)s[1]) { case '1': parsed = 0; break; case '2': parsed = 2; break; case '3': parsed = 4; break; } if ((char)s[3] == '2') { parsed++; } return parsed; } // ---------------------- // main.cpp: #include "schueler.cpp" #include "dateihandler.cpp" sm_schueler schueler[100]; int main(int argc, char *argv[]) { dateihandler *schuelerdatei = new dateihandler((char*) "/home/christian/programmieren/XML/Schülerdaten2.xml", schueler); return 0; } So. Nehmt mir bitte nicht übel, dass ich die alten Beiträge ganz rausgenommen hab'. Es wird sonst brutal unübersichtlich. Also, so wie da oben sieht der wesentliche Teil meines Codes aus. Es sind 5 Dateien. Beim Compilieren kommen so keine Fehler. Die kommen immer während der Laufzeit. Folgendes für "sm_schueler schueler[100]" in main.cpp: Ich brauche ein Array, das insgesamt bis zu 100 Schüler speichern können soll (am besten unbegrenzt viele) und auf dessen Elemente ich dann noch Zugriff haben will. Danke, Christian -- Chicago Transit Authority Rider's Rule #84: The CTA has complimentary pop-up timers available on request for overheated passengers. When your timer pops up, the driver will cheerfully baste you. -- Chicago Reader 5/28/82

Hi, On Thu, 10 Oct 2002, Christian Weickhmann wrote:

void sm_schueler::setName(const unsigned char* n) { strcpy(name, (char*)n); }

name wird nirgends initialisiert.

void sm_schueler::setVorname(const unsigned char* vn) { strcpy(name, (char*)vn); }

Wahrscheinlich vorname, wird aber auch nirgends initialisiert. Also gibt's natuerlich SEGVs. Du musst erst Speicher allozieren, wenn du auf ihn schreiben willst.

void dateihandler::getXMLschueler(char* dateiname, sm_schueler* s){

... char *name = s->getName(); char *vorname = s->getVorname(); int schuljahr = s->getSchuljahr();

fprintf(stderr, "%d %s, %s [.] : %d\n", nummer, *name, *vorname, schuljahr);

*name ist das erste Zeichen von name (== name[0]), und das crasht natuerlich gleich nochmal, wenn es als pointer ("%s") interpretiert wird. Du willst 'fprintf (stderr, "... %s ...", ..., name, vorname ...);' Beachte, das selbst damit das Programm noch crashen wird, da wie gesagt die name und vorname member auf keinen Speicher zeigen.

void dateihandler::oeffne(char* dateiname){ doc = xmlParseFile(dateiname); if (doc == NULL) { fprintf(stderr, "Die Datei %s konnte nicht geöffnet werden.", &dateiname);

Nein. Du willst bloss 'fprintf (...., dateiname);' nicht &dateiname. Du solltest dich _ernsthaft_ mit pointern, Addressen und Strings in C beschaeftigen.

Folgendes für "sm_schueler schueler[100]" in main.cpp: Ich brauche ein Array, das insgesamt bis zu 100 Schüler speichern können soll (am besten unbegrenzt viele) und auf dessen Elemente ich dann noch Zugriff haben will.

Wenn du nicht die STL Klassen verwenden willst, dann wuerde ich eine verkettete Liste empfehlen, die du einfach in sm_schueler einbauen kannst. Ala: struct sm_schueler { ... struct sm_schueler *next; }; sm_schueler *erster = 0; sm_schueler * get_new_schueler () { sm_schueler *n = new sm_schueler; n->next = erster; erster = n; } void iterate() { for (sm_schueler *s = erster; s; s = s->next) do_something (s); } void free_them () { sm_schueler *n, *n_next; for (n = erster; n; n = n_next) { n_next = n->next; delete n; } } Ciao, Micha.