fehler mit strcpy beim Auslesen aus txt Dateien

Ok, danke für den Hinweis. Nein, bestimmte Bücher vom Galileo Verlag habe ich nicht benutzt. Ich bin einfach ein Anfänger.
std::string ist jedoch neu für mich. Wie kann ich das nun in den vorhandenen Code implementieren?

SeppJ

Stockhausen schrieb:

Wie kann ich das nun in den vorhandenen Code implementieren?

Was soll das Programm überhaupt machen? Ich kann nur erkennen, dass da irgendwie formatierte Daten gelesen werden sollen. Stell mal das Format vor.

Das Programm soll insgesamt eine Liste von Personen auslesen und diese in ein Verhältnis zusammen stellen. Zunächst möchte ich einfach nur eine Datei auslesen, die folgendes Format hat:

1 "agostinho luis de ataide (rp-agoataide)"  URL "http://localhost:8080/mhk/servlet/do?action=show&id=rp-agoataide"
  2 "antonio carvalho coelho (rp-amz11-per14)"  URL "http://localhost:8080/mhk/servlet/do?action=show&id=rp-amz11-per14"
  3 "antonio galvao (rp-amz18-per7)"  URL "http://localhost:8080/mhk/servlet/do?action=show&id=rp-amz18-per7"
  4 "luis de seabra (rp-amz24-per17)"  URL "http://localhost:8080/mhk/servlet/do?action=show&id=rp-amz24-per17"
  5 "inacio coelho (rp-amz24-per19)"  URL "http://localhost:8080/mhk/servlet/do?action=show&id=rp-amz24-per19"

Und das soll halt so ausgegeben werden von dem Programm:

Gelesen: 1 mit Name agostinho luis de ataide mit der Identifikation rp-agoataide

Soweit funktioniert das ja auch, nur die Identifikation gibt das Programm nicht aus aufgrund des strcpy Befehls...

Videonauth

char identifikation[100];

Zeile 12

Marc-O

Hy

Die sache mit den string ist relative einfach, ersetzt "char" durch "string" und includiere noch den Header "<string>". Gleich vorneweg hier noch eine Referenz zu den String-Befehlen: http://www.cplusplus.com/reference/string/string/

Und statt folgenden

puffer[zaehler]=zeichen;
zaehler++;

wird dann dieser Code benutzt:

puffer.append(zeichen)

welcher Ebenfalls das Zeichen ans Ende des String-Buffers setzt.

MfG Marco

PS: ein puffer.clear() löscht den kompletten Buffer wieder.

EOP

Videonauth schrieb:

char identifikation[100];

Zeile 12

SeppJ

#include <iostream>
#include <string>

using namespace std;

struct Person // Eine Person, nicht mehrere, daher Einzahl
{
  int ordnungsnummer;
  string name;
  string identifikation;
  string url;     // Ich war mal so frei, zu raten, 
                  // dass du die URL auch noch möchtest
};

// Nun schreiben wir eine Funktion, die Daten in so ein Struct liest.
// Dieser geben wir einen speziellen komischen Namen, namens operator>>.
// Das ist ein besonderer Name, durch den wir diese Funktion später mittels
// stream >> person;
// aufrufen können und dann das gleiche passiert, als hätten wir
// operator>>(stream, person);
// geschrieben. Das nennt man Operatorüberladung

istream& operator>>(istream& in, Person& person)
{
  // Zuerst kommt die ordnungsnummer:
  in >> person.ordnungsnummer;   // Das kennst du schon. Mit der Erklärung von
                                 // oben verstehst du nun auch, dass dies auch
                                 // nur ein versteckter Aufruf der Funktion
                                 // operator>>(istream&, int&) ist. 

  // Jetzt lesen wir das erste Anführungszeichen:
  char anfuehrungszeichen = 0;
  in >> anfuehrungszeichen;
  // Teste, ob die Datei das richtige Format hat
  if (anfuehrungszeichen != '"')
    // Falls nicht, dann war das gar kein gültiger Datensatz. Setze Fehlerflag.
    in.setstate(ios::failbit);

  // hole nun alles was folgt bis ein '(' gefunden wird.
  getline(in, person.name, '(');
  // hole nun alles was folgt bis ein ')' gefunden wird.
  getline(in, person.identifikation, ')');

  // Lese das schließende Anführungszeichen und "URL" und teste Format
  anfuehrungszeichen = 0;
  string url;
  in >> anfuehrungszeichen;
  in >> url;
  if (anfuehrungszeichen != '"' or url != "URL")
    in.setstate(ios::failbit);

  // Weiter zum nächsten Anführungszeichen
  anfuehrungszeichen = 0;
  in >> anfuehrungszeichen;
  if (anfuehrungszeichen != '"')
    in.setstate(ios::failbit);

  // Und die URL bis zum nächsten Anführungszeichen
  getline(in, person.url, '"');

  // Und fertig. Damit eventuelle Fehler nach außen getragen werden können
  // Und damit man mehrere Funktionsaufrufe a la
  // streamobjekt >> wert1 >> wert2;
  // verketten kann, gibt man den nun um eine Person ausgelesenen Stream selbst
  // wieder zurück:
  return in;
}

// Das gleiche können wir auch für die Ausgabe machen, nur umgekehrt:
ostream& operator<<(ostream& out, const Person& person)
{
  return out << person.ordnungsnummer << " mit Name " << person.name 
             << " mit der Identifikation " << person.identifikation 
             << " und der URL " << person.url;
  // Eigentlich ist es nicht sehr schick, dass das Format der Ausgabe 
  // nicht dem Format der Eingabe entspricht, aber das war eine Anforderung
  // von dir.
}

// Nun noch eine kurze Demo, wie das dann aussehen kann:
#include <fstream>  // Du wolltest aus Dateien lesen
#include <vector>   // Du willst das Gelesene bestimmt auch irgenwo speichern

int main()
{
  vector<Person> personen;
  ifstream datei("personen.txt");
  Person person;
  while (datei >> person)  // Das ist doch schön, wenn das Hauptprogramm so aussieht.
    {
      cout << "Gelesen: " << person << '\n';
      personen.push_back(person);
    }

  // Im Vector "personen" sind nun alle eingelesenen Datensätze, bereit für Action!
}

Das sieht jetzt lang aus, das liegt daran, dass 40 Zeilen Kommentar sind. Wenn du die weglässt, ist das total kurz und einfach. Keine komplizierten Kontrollstrukturen, kein C-String-Gefrickel und nichts was irgendwie schiefgehen könnte (dein bisheriges Programm explodiert, wenn die Eingabe nicht den Erwartungen entspricht). Einfach nur eine Standardfunktion nach der anderen aufgerufen und diese die ganze schwere Arbeit (wie z.B. Schleifen ) machen lassen.

Werner Salomon

Hallo Stockhausen,

Verwende auf jeden Fall std::string, so wie Dir schon geraten wurde.

struct person // eine Person
{
    std::string name;
    int ordnungsnummer;
    std::string identifikation;
};

Und wenn Du Zahlen lesen möchtest, so lese auch Zahlen und keine Ziffern, die später interpretiert werden.

person p;
    datei >> p.ordnungsnummer;

Mit getline kannst Du einen std::string bis zu einem bestimmten Zeichen ('"' oder '(') einlesen.

getline( datei, p.name, '(' );

.. und wenn Du zwischendurch ein (druckbares) Zeichen überlesen möchtest, so kannst Du das mit

char dummy;
    datei >> dummy;

und schließlich kann mit ignore alles bis zu einem bestimmten Zeichen (z.B. Zeilenende) überlesen werden.

Zusammengefasst:

person p;
    datei >> p.ordnungsnummer;
    char dummy;
    datei >> dummy; // '"' vor'm Namen überlesen
    getline( datei, p.name, '(' );
    getline( datei, p.identifikation, ')' );
    datei.ignore( 9999, '\n' ); // bis zum Zeilenende überlesen

so könnte das Programm im Ganzen aussehen:

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <limits> // numeric_limits

template< char C >
std::istream& Char( std::istream& in )
{
    char c;
    if( in >> c && c != C )
        in.setstate( std::ios_base::failbit );
    return in;
}
std::istream& skipline( std::istream& in )
{
    return in.ignore( std::numeric_limits< std::streamsize >::max(), '\n' );
}

struct person // eine Person
{
    std::string name;
    int ordnungsnummer;
    std::string identifikation;
}; 

// --   eine Person einlesen
std::istream& operator>>( std::istream& in, person& p )
{   // Format:                       <nr>                    "<--- Name -->(<----- identifikation ->)
    return getline( getline( in >> p.ordnungsnummer >> Char<'"'>, p.name, '(' ), p.identifikation, ')' );
}

int main()
{
    using namespace std;
    vector< person > personen; // viele Personen
    {
        ifstream datei("personen.txt");
        if( !datei.is_open() )
        {
            cerr << "Fehler beim Oeffnen der Datei" << endl;
            return -2;
        }
        for( person p; datei >> p; datei >> skipline )
            personen.push_back( p );
    }
    cout << personen.size() << " Eintraege gelesen" << endl;
    // mache was mit 'personen'
    cin.get();
    return 0;
}

Oops - jetzt hat SeppJ auch schon geantwortet ..

Gruß
Werner

Hallo Seppj und Werner,
recht herzlichen Dank für die kompetente Hilfe! So sieht das natürlich auch schon viel übersichtlicher aus. Ich möchte im weiteren Verlauf des Programmes unter der Verwendung einer zweiten Textdatei bestimmte Verhältnisse zwischen den Personen in der Liste anzeigen lassen können. Da werde ich sicherlich nochmal die ein oder andere spezifische Frage hier äußern.
Grüße
Stockhausen

Hallo zusammen,
ich habe mal wieder etwas weiter gebastelt und stoße wieder mal auf Probleme. Auch wenn eure Lösungen natürlich wesentlich schicker sind als meine, habe ich basierend auf meinem Code weitergebastelt. Aber auch nun bekomme ich keine Ausgabe, obwohl der Compiler mir keinen Syntaxfehler angibt. Sieht jemand von euch das Problem?
Ich wäre schon voll auf zufrieden, wenn das Programm einfach laufen würde. Ich weiß, dass ihr wesentlich elegantere Lösung parat haben werdet, aber diese bringen mir nichts, wenn ich meinen eigenen Code noch nocht mal verstehe.

#include <iostream>
using namespace std;
#include <string.h>

#include <stdlib.h>
#include <fstream>

struct personen
   {
   struct personen *naechster;
   char name[64];
   int ordnungsnummer;
   char identifikation[64];
   } ;
enum zustand {imON,imNamen,imID};

struct personen *ladedaten(ifstream &datei);
struct personen *ladeperson(ifstream &datei);

int main()
{
struct personen *wurzel=NULL;

ifstream datei;

datei.open("personen.txt");

wurzel=ladedaten(datei);

while(wurzel!=NULL)
     {
         cout << wurzel->name << " besitzt die  " << wurzel->ordnungsnummer << "mit der Identifikation " << wurzel->identifikation
          << "." << endl;
     wurzel=wurzel->naechster;
     }
}

struct personen *ladedaten(
ifstream                   &datei)
{
struct personen *wurzel=NULL, *jetzt, *neu;

while(!datei.eof())
     {
     neu=ladeperson(datei);
     if (neu!=NULL)
        {
        if (wurzel==NULL) wurzel=neu;
        else jetzt->naechster=neu;
        jetzt=neu;
        }
     }

return wurzel;
}

struct personen *ladeperson(
ifstream                    &datei)
{
struct personen *fest;
char puffer[100],zeichen;
int zaehler;
enum zustand zustand;

fest=new struct personen;
fest->naechster=NULL;

zustand=imON;
zaehler=0;
for (;;)
    {
    datei.get(zeichen);
    if (datei.eof()) break;
    switch(zeichen)
       {
    case '"':
       puffer[zaehler]='\0';
       zaehler=0;
       fest->ordnungsnummer=atoi(puffer);
       zustand=imNamen;
       break;
    case '(':
       if (zustand!=imON)
          {
          puffer[zaehler]='\0';
          zaehler=0;
          strcpy(fest->name,puffer);
          zustand=imID;
          }
       break;
    case ')':
       if (zustand!=imON)
          {
          puffer[zaehler]='\0';
          zaehler=0;
          strcpy(fest->identifikation,puffer);
          }
       puffer[zaehler]='\0';
       zaehler=0;
       break;
    default:
       puffer[zaehler]=zeichen;
       zaehler++;
       break;
       }
    }
}

SeppJ

Warum benutzt du immer noch char-Arrays? Warum bastelst du selber eine Liste? Warum benutzt du C-Funktionen, deren Erfolg/Misserfolg man nicht in allen Fällen prüfen kann? Wieso versuchst du noch nicht einmal, dies zu prüfen? Wieso hast du dir nicht ein einziges der vielen Konzepte die dir gezeigt wurden mal angeguckt? Wieso hast du keinen einzigen der Tipps die dir gegeben wurden umgesetzt? Wieso hast du keinen einzigen der vielen Hinweise auf Fehler in deinem Programm befolgt? Wieso fügst du stattdessen noch Pointergefrickel als zusätzliche Fehlerquelle ein? Wieso nullst du sinnlos deine Zeiger und vertuscht so mögliche Fehler? Wieso nullst du deine Zeiger mit NULL, statt mit 0 oder nullptr? Wieso gibt es in deinem Programm zwar news, aber keine deletes? Wieso benutzt du keine Objekte, die sich selber verwalten (RAII)?

Irgendwie bist du selber Schuld, wenn das nicht läuft.

Ach ja: Dein ladeperson hat kein return, obwohl es einen Rückgabewert ungleich void hat. Das hätte dir dein Compiler auch gesagt, würdest du mal Warnungen anschalten.

Atme mal in eine Tüte... Wieso so gehässig? Es sind nicht alle Menschen auf der Welt so gewandt beim Programmieren, daher verwende ich eure Angaben nicht, weil ich Anfänger bin und eure Codes nicht verstehe und es gerne schrittweise erlernen möchte, aber dabei wohl lieber in Zukunft auf dieses Forum hier verzichten werde.
Mein Compiler gibt zu diesem Code keine Fehlermeldung aus, die ich sonst sehr gerne beherzigt hätte, aber der große SeppJ kann ja in die Zukunft sehen.
Ein einfacher Hinweis zu dem Fehler hätte es auch getan.

SeppJ

Stockhausen schrieb:

Atme mal in eine Tüte... Wieso so gehässig?

Weil das Problem eindeutig selbstgemacht ist. Und du weißt es besser, denn es wurde dir gleich mehrfach erklärt. Es muss ja nicht gleich alles überarbeitet werden, aber da wurde keine einzige Zeile korrigiert, sondern stattdessen noch mehr und noch größere Fehlerquellen hinzugefügt.

Stockhausen schrieb:

Atme mal in eine Tüte... Wieso so gehässig?

Weil viele Leute viel Arbeit investiert haben, um dir zu helfen und absolut nichts davon angekommen ist.

Mein Compiler gibt zu diesem Code keine Fehlermeldung aus, die ich sonst sehr gerne beherzigt hätte, aber der große SeppJ kann ja in die Zukunft sehen.

Deshalb auch der Hinweis, dass du die Warnungen einschalten sollst.

Ein einfacher Hinweis zu dem Fehler hätte es auch getan

Dein ganzes Programm ist so programmiert, das wird noch viele viele weitere Fehler erzeugen. Ich und alle anderen haben dir erklärt, wieso.

Ich habe mich mehrfach dafür bedankt, dass "viele Leute" - also Werner und Du zzgl. einige Tipps der weiteren User, mir ein ganz anderes Konzept dargelegt haben. Leider kann ich damit noch nichts anfangen, weil ich - wie ich bereits erwähnt habe - Anfänger bin. Dann tut es mir leid, da ihr viel Arbeit investiert habt. Wenn ich Klavier spielen lerne, versuche ich mich auch nicht an dem Presto Satz aus der Beethoven-Mondscheinsonate. Videonauth, ist derjenige der mich auf den Fehler hingewiesen hat, dass das Array nicht richtig definiert ist, das hilft mir weiter. Dieser Code ist nur als Lernschritt gedacht und da muss man eben Fehler machen. Ist mir schon klar, dass ist damit nicht die Computerlinguistik revolutioniere, aber ich hatte gehofft bei freundlichem spezifischen Fragen Unterstützung zu bekommen.
Ich kann es total verstehen, wenn ihr Geeks genervt seid und Leute hier ohne Eigeninitiative Komplettlösungen verlangen. Ich versuche mich da selbst durchzuarbeiten und der ein oder andere Hinweis hilft dann. Im Laufe der Zeit erreiche ich dann auch den Skill um eure wesentlich eleganteren Methoden, die genannt worden sind, anwenden zu können.

EOP

SeppJ vs Stockhausen aka der Jüngling im Feuerofen:
http://www.youtube.com/watch?v=3XfeWp2y1Lk

pyhax

Vergleich (wegen der "Einfachheit")
Char arrays (das was du benutzt) vs std::string
char arrays: (kopieren)

char a[100] = "Test"; // Dazu die Gefahr das dieser Buffer zu klein ist.
char b[100];
strcpy(b, a);

std::string: (kopieren)

std::string text = "Test";
std::string text2 = text; //Einfach =, std::string kümmert sich automatisch um die richtige Größe des Buffers und erweitert diesen auch bei Bedarf.

Handgemachte Liste vs std::vector
Mit Handgemachter Liste

struct personen {
    struct personen *naechster;
    char name[64];
    int ordnungsnummer;
    char identifikation[64];
} ;

personen * p = new personen; // Du musst dich um die Freigabe kümmern.
p->naechster = new personen; // Einfügen, auch dieser Speicher muss Freigegeben werden.
p->naechster->naechster = NULL;

Mit std::vector (und std::string)

struct Person {
    std::string name;
    int ordnungsnummer;
    std::string id;
};

std::vector<Person> p;
Person neu; // Dieses Objekt wurde nicht mit new angelegt, sondern wurde direkt auf dem Stack erstellt. Das ist a) schneller und b) brauchst du dich nicht um die Freigabe kümmern.
neu.name = "Hello";
neu.ordnungsnummer = 1;
neu.id = 3;
p.push_back(neu); // Einfügen
p.push_back(neu); // Und gleich nochmal. std::vector kümmert sich automatisch um die richtige Größe des Buffers

Was ist davon nun einfacher? Die handgemachten Sachen, oder die ganzen Hilfsmittel, die dir viel Arbeit abnehmen? Willst du wirklich darauf verzichten?

Stockhausen schrieb:

Wenn ich Klavier spielen lerne, versuche ich mich auch nicht an dem Presto Satz aus der Beethoven-Mondscheinsonate.

Und da liegt das Problem: Du baust dir gerade ein Klavier...

Werner Salomon

Hallo Stockhausen,

ich kann den Frust von SeppJ verstehen, mir geht es ja ähnlich, obwohl ich solche Situationen inzwischen mehr mit einem lachenden denn mit einem weinenden Auge hinnehme. Ich akzeptiere aber auch Deinen Wunsch wissen zu wollen, warum Dein Programm nicht funktioniert.

Ganz vordergründig geht es in der Funktion ladeperson schief, weil Du hier ohne Zustandskontrolle (Variable zustand) auf ein '"' reagierst, welches aber pro Zeile mehr als einmal vorkommt.
Ein einfacher Hack dieses Fehlers (Fehlerbehebung wäre vermessen) besteht darin, hinter der Zeile 97 noch folgendes einzufügen:

strcpy(fest->identifikation,puffer); // Zeile 97
                datei.ignore( 9999 /*maximal so viel Zeichen*/, '\n' ); // <-- neu
                return fest; // <-- neu

da identifikation, der letzte Member ist, der gelesen ist, so wird anschließend einfach der Rest der Zeile ignoriert, und dann die Funktion verlassen. Mit der Datei, die Du hier gepostete hast, funktioniert das dann.

Zeile 97 ist übrigens eine sehr interessante Stelle. Genau hier wäre es nämlich möglich, mit einer wohl präperierten Datei 'personen.txt' den PC zu kapern, auf dem dieses Programm läuft. Wenn die Benutzerrechte reichen, kann ein eingeschleustes Programm hier alles machen, was ein Programm auf einem PC machen kann - vom Versenden von tausenden von SPAM-Mails mit Deinem Account als Absender bis zum Formatieren der Festplatte.

arghonaut schrieb:

Stockhausen schrieb:

Wenn ich Klavier spielen lerne, versuche ich mich auch nicht an dem Presto Satz aus der Beethoven-Mondscheinsonate.

Und da liegt das Problem: Du baust dir gerade ein Klavier...

das war auch mein Gedanken, bevor ich die Beiträge dazu gelesen habe!

Stockhausen- es ist Dir sicher nicht bewusst - aber Du versuchst tatsächlich, Dir die Funktionen zusammen zu bauen, die es schon gibt und mit denen Du spielen kannst, wenn man es denn kann.

Vielleicht ein Anfang: Gebe den Membern name und identifikation den Typ std::string. Du benötigst dann noch ein #include <string>. person wird dann zu

struct personen
{
    struct personen *naechster;
    std::string name;
    int ordnungsnummer;
    std::string identifikation;
} ;

Anschließend musst Du die Zeilen 88 und 97 anpassen:

fest->name = puffer; // vorher: strcpy(fest->name,puffer);
....
                fest->identifikation = puffer; // vorher: strcpy(fest->identifikation,puffer);

Dann kannst Du auch auf das #include <string.h> verzichten.

Gruß
Werner

Hey,
danke für die weiteren Vorschläge! Ich werde mich damit näher befassen, doch im Moment komme ich noch nicht dazu.
grüße
Stockhausen

C.plusplus 0

Hallo Zusammen,

ich habe mich auch mal an der Aufgabe versucht, doch leider funktioniert sie noch nicht ganz. Ich habe mich darum bemüht, die Ratschläge zu befolgen, aber ich bin auch nur eine Anfängerin...
Mir ist zwar bewusst, dass der Beitrag schon was länger her ist, aber ich dachte, ich versuche mal mein Glück

#include <iostream>
using namespace std;
#include <string>

#include <stdlib.h>
#include <fstream>

struct personen
{
    struct personen *naechster;
    std::string name;
    int ordnungsnummer;
    std::string identifikation;
} ;
enum zustand {imON,imNamen,imID};

struct personen *ladedaten(ifstream &datei);
struct personen *ladeperson(ifstream &datei);

int main()
{
struct personen *wurzel=NULL;

ifstream datei;

datei.open("personen.txt");

wurzel=ladedaten(datei);

while(wurzel!=NULL)
     {
         cout << wurzel->name << " besitzt die  " << wurzel->ordnungsnummer << "mit der Identifikation " << wurzel->identifikation
          << "." << endl;
     wurzel=wurzel->naechster;
     }
}

struct personen *ladedaten(
ifstream                   &datei)
{
struct personen *wurzel=NULL, *jetzt, *neu;

while(!datei.eof())
     {
     neu=ladeperson(datei);
     if (neu!=NULL)
        {
        if (wurzel==NULL) wurzel=neu;
        else jetzt->naechster=neu;
        jetzt=neu;
        }
     }

return wurzel;
}

struct personen *ladeperson(
ifstream                    &datei)
{
struct personen *fest;
char puffer[100],zeichen;
int zaehler;
enum zustand zustand;

fest=new struct personen;
fest->naechster=NULL;

zustand=imON;
zaehler=0;
for (;;)
    {
    datei.get(zeichen);
    if (datei.eof()) break;
    switch(zeichen)
       {
    case '"':
       puffer[zaehler]='\0';
       zaehler=0;
       fest->ordnungsnummer=atoi(puffer);
       zustand=imNamen;
       break;
    case '(':
       if (zustand!=imON)
          {
          puffer[zaehler]='\0';
          zaehler=0;
          fest->name = puffer;
          zustand=imID;
          }
       break;
    case ')':
       if (zustand!=imON)
          {
          puffer[zaehler]='\0';
          zaehler=0;
          fest->identifikation=puffer;
          }
       puffer[zaehler]='\0';
       zaehler=0;
       break;
    default:
       puffer[zaehler]=zeichen;
       zaehler++;
       break;
       }
    }
}