Ich möchte gerne aus einer txt Datei auslesen und bestimmte Parameter in einem Programm auslesen lassen.
Nun bekomme ich die Fehlermeldung, dass es sich um eine ungültige Umwandlung von char in char* handelt. Der Fehler findet sich laut Compiler in Zeile 55. Kann man mit strcopy so keine weiteren Informationen im Array speichen?

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

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

int main()
{
struct personen person;
char puffer[100],zeichen;
int zaehler;
enum zustand zustand;

ifstream datei;

datei.open("personen.txt");

zustand=imON;
zaehler=0;
for (;;)
    {
    datei.get(zeichen);
    if (datei.eof()) break;
    switch(zeichen)
       {
    case '"':
       puffer[zaehler]='\0';
       zaehler=0;
       person.ordnungsnummer=atoi(puffer); //atoi = convert string to integer
       zustand=imNamen;
       break;
    case '(':
       if (zustand!=imON)
          {
          puffer[zaehler]='\0';
          zaehler=0;
          strcpy(person.name,puffer);
          zustand=imID;
          }
       break;
    case ')':
       if (zustand!=imID)
          {
          puffer[zaehler]='\0';
          zaehler=0;
          strcpy(person.identifikation,puffer);
          zustand=imID;
          }
       puffer[zaehler]='\0';
       zaehler=0;
       cout << "Gelesen: " << person.ordnungsnummer << " mit Name " << person.name << "und Identifikation " <<
               person.identifikation << endl;
       break;
    default:
       puffer[zaehler]=zeichen;
       zaehler++;
       break;
       }
    }
{
/* bitte ignorieren; nur bis zu Ihrer Anmeldung notwendig */
int x;
cin >> x;
}

}

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.

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

Zeile 12

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.

char identifikation[100];

Zeile 12

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.

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

#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;
       }
    }
}

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?

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.

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?

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

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

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;
       }
    }
}

struct beziehungen *sucheid(struct beziehungen *wurzel, char *bezeichnung)
    {
        while (wurzel != NULL)
        {
            if (!strcmp(wurzel->pate, bezeichnung)) return wurzel;
            wurzel = wurzel->naechster;
        }

        return NULL;
    }