Hallihallo,

ich bekommen den Fehler: error C2106: '=': Linker Operand muss ein L-Wert sein(Zeile 51)

Ich weiß zwar was dieser Fehler bedeutet:
3=x --> macht keine Sinn, weil x in 3 speichern.. naja --> Linker Operand muss ein L-Wert sein.
x=3 --> macht sinn, da man x 3 zuweist, also 3 in x speichert.

Aber ich verstehe das bei mir nicht mein linker Operand ist ja eine Struktur und diesen will ich halt ein ausgelesenens Wort zuweisen.

Oder weise ich da überhaupt falsch zu?

Funktion des Programms: Es soll einfach die 1. Zeile auslesen(indem Fall 1 Wort) und dann in "vorname" speichern.

In adressen.txt stehen einfach Adressen z.b:
Franz
Müller
Hofburgstraße 13
Schuhgröße 37
Größe 175

und noch mehr Adressen...

Franz soll in vorname, Müller in Nachname usw. gespeichert werden und wenn die Schuhgröße unter 38 ist, dann soll es die gesamte Adresse auf dem Bildschirm ausgeben.

Das Programm ist noch nicht fertig, da ich den eine Fehler mal beheben will.


Programm:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

#include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h>   #define MAXSTRING 100   struct adresse {   char  vorname[MAXSTRING];   char  nachname[MAXSTRING];   char  strasse [MAXSTRING];   char  ort[MAXSTRING];   char  PLZ[MAXSTRING]; };   struct personendaten_struct {   struct adresse adresse;   int    schuhgroesse;   float  groesse; };   typedef struct personendaten_struct personendaten;       int main() {   FILE*fileio = NULL;     char text[MAXSTRING];   int x=0;   personendaten theperson;       fileio=fopen("adressen.txt","r");   if(fileio == NULL)   {     printf("Fehler beim LESEN der Datei adressen.txt");     exit(-1);   }     while(!feof(fileio))   {     fgets(text,MAXSTRING,fileio);     x++;         if(x == 1)     {       theperson.adresse.vorname=text;     }   }     fclose(fileio);     return(0); }

mfg Googlehupf

Hallo,

ein Array ist kein L-Wert. Um Arrays zu kopieren, musst du z.B. memcpy verwenden. In diesem Fall ist aber strcpy angebrachter, da du eine Zeichenkette kopieren willst.

Grüße,
Matthias

Ich danke dir.
Hab das Programm jetzt geschrieben, aber ich bräuchte vielleicht paar Tipps, Hinweise bitte .

Die konkrete Aufgabenstellung ist:
Kurzbeschreibung : Programm zum Arbeiten mit Strukturen.
Schreiben Sie ein Programm das die
personendaten (typedef struct ......) von einer Textdatei einliest
und alle Personen und deren Adresse ausgibt die eine Schuhgrösse kleiner 38
haben.

In adressen.txt steht(die 5. Zeile ist die PLZ, die 6. die Schuhgröße und die 7. Zeile die Größe, also die zeilen jeweils bei den Adressen):

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

Lieselotte Musterschülerin Buseckerstrasse 44 Heppenheim 4443 38 172   Peter Jackson Mall street 10 USA 7860 45 189   Harry Potter Hogwarts 45 England 9234 35 178   Tom Turbo Turbohofgasse 1 Torbio 0001 22 156

So hab ichs versucht(in den comments steht warum das es maybe nicht funktioniert):

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

#include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h>   #define MAXSTRING 100   struct adresse {   char  vorname[MAXSTRING];   char  nachname[MAXSTRING];   char  strasse [MAXSTRING];   char  ort[MAXSTRING];   char  PLZ[MAXSTRING]; };   struct personendaten_struct {   struct adresse adresse;   char   schuhgroesse[MAXSTRING];   char  groesse[MAXSTRING]; };   typedef struct personendaten_struct personendaten;       int main() {   FILE*fileio = NULL;     char text[MAXSTRING];   int x=0;   int i=0;   personendaten theperson;       fileio=fopen("adressen.txt","r");   if(fileio == NULL)   {     printf("Fehler beim LESEN der Datei adressen.txt");     exit(-1);   }     while(!feof(fileio))   {     fgets(text,MAXSTRING,fileio);     x++;         if(x == 1)     {       strncpy(theperson.adresse.vorname,text,MAXSTRING);     }       if(x == 2)     {       strncpy(theperson.adresse.nachname,text,MAXSTRING);     }       if(x == 3)     {       strncpy(theperson.adresse.strasse,text,MAXSTRING);     }       if(x == 4)     {       strncpy(theperson.adresse.ort,text,MAXSTRING);     }       if(x == 5)     {       strncpy(theperson.adresse.PLZ,text,MAXSTRING);       }       if(x == 6)     {       strncpy(theperson.schuhgroesse,text,MAXSTRING);       i=atoi(text);//wenn dann text="38" ist, dann ist ja i != 38, weils ja ungewandelt wird von string in int oder?       if(i < 38)       {         printf("%s",theperson.adresse.vorname);         printf("%s",theperson.adresse.nachname);         printf("%s",theperson.adresse.strasse);         printf("%s",theperson.adresse.ort);         printf("%s",theperson.adresse.PLZ);         printf("%s",theperson.schuhgroesse);       }     }       if(x == 7)     {       strncpy(theperson.groesse,text,MAXSTRING);       x=0;     }   }     fclose(fileio);     return(0); }

Danke im voraus!

Hi

also zuerst einmal würde ich Schuhgröße etc. als int speichern.

In der Schliefe, statt eine Zeile einlesen und if 1 bis 7:
Warum nicht pro Schleifendurchgang alle 7 Zeilen einlesen?

Warum nur ggf. bei jeder 6. Zeile Personen je nach Schuhgröße ausgeben?
Wenn du, wie im oberen Absatz, alles in einem Schleifendurchgang einliest,
hast du das "Problem" nicht.

puts statt printf-%s nehmen. Ist nicht falsch, aber vergleichsweise langsam.

Und doch, atoi("38") ergibt die Zahl 38. Das ist der alleinige Sinn von atoi.

Was ist jetzt eigentlich die Frage gewesen?

Zitat von sheel

In der Schliefe, statt eine Zeile einlesen und if 1 bis 7:
Warum nicht pro Schleifendurchgang alle 7 Zeilen einlesen?

Mh... fgets liest doch nur bis zu einen \n. Befehle die weiter Zählen hätten wir noch nicht gelernt.
Wie könnt das den gehn(ohne einen neuen Befehl )?

Warum nur ggf. bei jeder 6. Zeile Personen je nach Schuhgröße ausgeben?

Naja, weil ja "text" nach der 7. Zeile wieder anderst ist... und ich die Schuhgröße steht ja in der 6. Zeile.

Was ist jetzt eigentlich die Frage gewesen?

Eigentlich eh wie man das fehlerhafte Programm besser schreiben könnte.

Hi.

Hinzu kommt, das du überhaupt keine Eingaben auf Erfolg prüfst. Du mußt doch sicherstellen, dass du einen Datensatz auch komplett eingelesen hast!

Warum liest du denn die Daten nicht gleich in die Struktur ein?

Bsp:

Code c:

1 2 3 4 5

while (fgets(p.name, sizeof(p.name), datei) != NULL      && fgets(p.vorname, sizeof(p.vorname), datei) != NULL      && fgets(...) // ... usw. { }

Noch besser wäre es, du würdest dir eine Funktion zum Einlesen in die Struktur schreiben die du dann in der Schleife immer nur aufrufen mußt.

Gruß

Außerdem, warum verwendest du nicht statt fputs/fgets eher die Funktionen fread/fwrite? Damit könntest du die komplette Struktur schreiben und lesen und müsstest nicht an den Struktur-Elementen rum pfriemeln. Du verwendest ja nicht mal Pointer in deinen Strukturen, sollte also ohne Probleme funktionieren.

Beispiel:

Code c:

1 2 3 4

if(fwrite(&theperson, sizeof(personendaten), 1, fp) != 1) {   perror(strerror(errno)); // Für errno brauchst du errno.h und für strerror string.h }

Zitat von saftmeister

Außerdem, warum verwendest du nicht statt fputs/fgets eher die Funktionen fread/fwrite? Damit könntest du die komplette Struktur schreiben und lesen und müsstest nicht an den Struktur-Elementen rum pfriemeln. Du verwendest ja nicht mal Pointer in deinen Strukturen, sollte also ohne Probleme funktionieren.

Zumindest bis man den Compiler, dessen Einstellungen oder die Plattform wechselt. Compilern steht es nämlich frei, beliebig Füllbytes zwischen Membern einer Struktur einzufügen. Da kann es schnell zu Inkompatibilitäten kommen. Im allgemeinen ist das Schreiben oder Lesen von Strukturen mit einem Aufruf also nicht zu empfehlen, es sei denn man weiß genau, was man tut (z.B. wenn man die Füllbytes per Compilerdirektive deaktiviert hat).

Abgesehen davon wäre das Format dann nicht mehr menschenlesbar.

Grüße,
Matthias

Gut, was ist mit attribute packed? Dann wäre "nur" das Problem, das die Datentypen alle die gleichen Byte-Größen haben müssen, zu mindest wenn man den Compiler wechselt.

Zitat von saftmeister

Gut, was ist mit attribute packed? Dann wäre "nur" das Problem, das die Datentypen alle die gleichen Byte-Größen haben müssen, zu mindest wenn man den Compiler wechselt.

Wie gesagt: wenn man weiß was man tut, dann kann man das schon so machen. Einem Anfänger würde ich aber nicht dazu raten, zumindest nicht ohne diesen Fallstrick zu nennen.

Grüße,
Matthias

Zitat von deepthroat

Hi.
Warum liest du denn die Daten nicht gleich in die Struktur ein?

Bsp:

Code c:

1 2 3 4 5

while (fgets(p.name, sizeof(p.name), datei) != NULL      && fgets(p.vorname, sizeof(p.vorname), datei) != NULL      && fgets(...) // ... usw. { }

Mh ok danke, aber ich versteh nicht warum eine while() hier?

Und was bedeutet dann "sizeof(p.name), datei) != NULL"?

Gruß

Googlehupf

Code cpp:

1	fgets(p.name, sizeof(p.name), datei)

Liest einen String von datei in p.name rein, maximal aber sizeof(p.name) Byte.
Weil mehr passt ja nicht rein (sizeof ergibt in dem Fall die Byteanzahl).

Das "!=NULL" deswegen, weil fgets im Fehlerfall NULL liefert (Fehler ist zB auch das Dateiende).

Die while liest damit so lange ganze Personen ein, bis es nicht mehr geht bzw. die Datei aus ist.
In der Schleife hast du eine fertige Person, mit der du was machen kannst.
Im nächsten Schleifendurchgang die nächste Perosn usw.

Moin,

Zitat von Googlehupf

ich versteh nicht warum eine while() hier?

weil fgets die Quelle zeilenweise einliest - vgl. hier :
http://pronix.linuxdelta.de/C/standa...ung_19_3.shtml

Zitat von Googlehupf

Und was bedeutet dann "sizeof(p.name), datei) != NULL"?

so ist das nicht zu lesen, sondern ob das Ergebnis von fgets ungleich null ist :

Code cpp:

1	fgets( p.name, sizeof(p.name), datei ) != NULL

vgl. auch hier den obigen Link!

Gruß
Klaus

Zitat von Googlehupf

Mh ok danke, aber ich versteh nicht warum eine while() hier?

Weil du alle Datensätze verarbeiten willst.

Vermutlich hast du nicht verstanden, dass das die einzige Schleife ist. Der Schleifenblock würde aber nur ausgeführt werden wenn alle Zeilen die zu einem Datensatz gehören eingelesen sind.

Wie gesagt, eine Funktion dafür wäre deutlich schöner:

Code c:

1 2 3 4 5 6 7 8 9 10 11

int readRecord(FILE* f, personendaten* ppd) {   return (fgets(ppd->name, sizeof(ppd->name), f) != NULL &&      fgets(ppd->vorname, sizeof(ppd->vorname), f) != NULL &&      ...; }   ...   while (readRecord(datei, &p)) {   ... }

Gruß

Zitat von sheel

Code cpp:

1	fgets(p.name, sizeof(p.name), datei)

Liest einen String von datei in p.name rein, maximal aber sizeof(p.name) Byte.
Weil mehr passt ja nicht rein (sizeof ergibt in dem Fall die Byteanzahl).

Also, fgets ist so definiert: char * fgets ( char * str, int num, FILE * stream )

Da wo int num steht, steht sizeof(.....), aber warum kann man hier nicht die maximale größe des Strings hineinschreiben in unserem Fall?
Also: MAXSTRING ?

Das "!=NULL" deswegen, weil fgets im Fehlerfall NULL liefert (Fehler ist zB auch das Dateiende).

Die while liest damit so lange ganze Personen ein, bis es nicht mehr geht bzw. die Datei aus ist.
In der Schleife hast du eine fertige Person, mit der du was machen kannst.
Im nächsten Schleifendurchgang die nächste Perosn usw.

Wenn man das !=NULL weglässt, dann müsste man theoretisch eine while(!feof(....)) schreiben oder?