Problem mit "schreiben" in Struct

Django2012

Hallo Leute

ich programmiere normal Siemens SPS in AWL und SCL (so ne Art Pascal).
Habe jetzt vor 2 Wochen angefangen mit C (Hobby).
Dachte ich hab´s so halbwegs gerafft für meine Bedürfnisse , jetzt hab ich aber ein Problem wo ich einfach nicht weiterkomme und aus meinem Buch (Gallilieo C von a-z und Markt & Technik C & C++) auch nicht wirklich weiterkomme.

Ist ein reines Testprogramm und soll "beliebige" Strings in eine Struktur schreiben. Hier mal ein bisschen "Pseudo"code

struct daten{char *s1; char *s2; char *s3;}test1;

int main ()
{
FILE *fptr;
fptr = fopen("test.txt", "r+");   /* keine Abfrage ob test.txt existiert, */

fgets(&test1.s1, 100, stdin);
bla bla bla

Ich habe schon probiert mit sizeof(test1) oder sizeof(test1.s1) , was aber nur die Größe des / der Pointer liefert.

Malloc hat mich auch nicht wirklich weitergebracht, da ich ja die größe des eingegebenen Textest im "voraus" nicht weiß.
String-Länge hab ich noch nicht probiert "einzubauen", da ich nicht genau weiß wie.

Ich muss doch vor benutzen, dem "Pointer" *s1 irgendwo mal mitteilen wie "groß" er ist, bzw. auf was er zeigt?

Ich hoffe es kann mir jmd. weiterhelfen, bzw. ihr versteht was ich meine.

Es soll quasi so werden , das z.b.: "das ist ein Text" eingegeben werden kann und in meiner Struktur abgespeichert wird, es soll aber auch mit "das ist ein viel längerer test mit viel mehr Zeichen und noch vielem mehr bla bla lba" gespeichert werden kann.

Absolut keine Ahnung wie ich das anstellen kann.

SeppJ

Hier fehlen dir offensichtlich jegliche Grundlagen, wie Zeichenketten in C funktionieren. Eine Zeichenkette ist kein char-Pointer. Ein char-Pointer kann auf eine Zeichenkette zeigen. Hier bei dir zeigen sie aber irgendwo ins nichts. Selbst wenn sie irgendwohin zeigen würden, müsstest du den gewünschten Inhalt dorthin schreiben, nicht über den char-Pointer selbst (der dadurch schließlich überschrieben würde und dann auf irgendwelchen Müll zeigt.)

Es ist nicht überraschend, dass dir diese Grundkenntnisse fehlen. Die beiden von dir genannten Bücher sind wohl die schlimmsten, die es auf dem deutschsprachigen Markt gibt. Voller Fehler und Ungenauigkeiten, fast alle "dummen" Fragen hier im Forum gehen auf diese Bücher zurück (besonders auf das erste). Siehe:
http://www.c-plusplus.net/forum/272350
Zum Lernen ungeeignet. Da das Schlimmste was man lernen kann, etwas Falsches ist, solltest du diese Bücher nicht weiter benutzen.

Zunächst einmal brauchst du natürlich Speicher auf den deine s1, s2, s3 zeigen.
den besorgst du dir mit malloc bzw. realloc.

Dann liefert dir &test1.s1 die Adresse von s1. Also da wo der Pointer selber die Adresse ablegt.
Was du möchtest ist der Speicher auf den s1 verweist und den bekommst du ganz einfach mit test1.s1

Zum Schluss sei noch angemerkt, das der Auto des Buches in diesem Forum kein Ansehen genießt.

Du kannst ja mal die Suchfunktion im Forum (realloc und Galileo bzw. Wolf) nutzen um dir einen Überblick zu verschaffen.

Django2012

SeppJ schrieb:

Hier fehlen dir offensichtlich jegliche Grundlagen, wie Zeichenketten in C funktionieren. Eine Zeichenkette ist kein char-Pointer. Ein char-Pointer kann auf eine Zeichenkette zeigen. Hier bei dir zeigen sie aber irgendwo ins nichts. Selbst wenn sie irgendwohin zeigen würden, müsstest du den gewünschten Inhalt dorthin schreiben, nicht über den char-Pointer selbst (der dadurch schließlich überschrieben würde und dann auf irgendwelchen Müll zeigt.)

Es ist nicht überraschend, dass dir diese Grundkenntnisse fehlen. Die beiden von dir genannten Bücher sind wohl die schlimmsten, die es auf dem deutschsprachigen Markt gibt. Voller Fehler und Ungenauigkeiten, fast alle "dummen" Fragen hier im Forum gehen auf diese Bücher zurück (besonders auf das erste). Siehe:
http://www.c-plusplus.net/forum/272350
Zum Lernen ungeeignet. Da das Schlimmste was man lernen kann, etwas Falsches ist, solltest du diese Bücher nicht weiter benutzen.

Ähmmm..ja da hast du wohl recht. Beruflich haben mich zeichenketten noch nie interessiert, die paar Strings die ich mal verarbeiten muss kommen evtl. aus nem Barcode-scanner und lasen sich Zeichen für Zeichen in ein Byte Array kopieren.
Aber das tut jetzt hier nichts zur Sache. Ich bin ja dankbar für deinen Beitrag, aber helfen tut mir das jetzt nicht wirklich. Du hast festgestellt das meine testprogramm nicht funktioniert und meine Bücher Mist sind. Toll, das hilft mir ungemein. (galileo buch war kostenlos und das referenzbuch hat 3 Euro gekostet. Hey ,wie schlecht kann ein Referenzbuch sein? )

@@DirkB "Zunächst einmal brauchst du natürlich Speicher auf den deine s1, s2, s3 zeigen.
den besorgst du dir mit malloc "

Woher weiß ich wieviel Speicher ich zuweisen muss? Und laut SeppJ funktioniert es ja auch gar nicht so wie ich vorhabe /hatte ?

Jetzt kenn ich mich noch weniger aus als davor.

das thema gab es letztens hier: http://www.c-plusplus.net/forum/320112
dazu kannst du dir diese funktion angucken: http://stackoverflow.com/questions/314401/how-to-read-a-line-from-the-console-in-c/314422#314422

diese getline funktion ist allerdings sehr oft das berühmte schießen mit kanonen auf spatzen.
meistens ist die maximale anzahl der einzugebenden zeichen bekannt, also wählt man einfach ein array konstanter größe.
wenn zu viele zeichen eingegeben werden, kann man im programm entsprechend reagieren, z.b. die eingabe als ungültig erklären und eine neue eingabe anfordern.

Django2012 schrieb:

Woher weiß ich wieviel Speicher ich zuweisen muss?

Weißt du erst hinterher genau. Also erstmal Speicher besorgen und dann weitersehen. wenn er nicht reicht, mehr Speicher besorgen.

Django2012 schrieb:

Und laut SeppJ funktioniert es ja auch gar nicht so wie ich vorhabe /hatte ?

Wo hat er da geschrieben? Letztendlich hat er das gleiche ausgesagt wie ich.

Django2012 schrieb:

Jetzt kenn ich mich noch weniger aus als davor.

Weil du dich noch nicht mit Arrays und Zeigern beschäftigt hast.
Hast du denn schon strcpy/strcat nachprogrammiert? Mit Zeigern und mit Arrays?

SeppJ

Django2012 schrieb:

Toll, das hilft mir ungemein.

Da wäre jede Menge Hilfe drin, wenn du sie nur annehmen würdest. Wenn du unbedingt eine Liste brauchst :
-Bücher verbrennen. Dies ist kein Scherz.
-Vernünftiges Buch holen
-Da drin die genannten Stichworte nachschlagen oder besser: Noch einmal von vorne anfangen.
-Damit das Programm korrekt schreiben, bei Schwierigkeiten nochmals fragen.
-???
-Profit

(galileo buch war kostenlos und das referenzbuch hat 3 Euro gekostet.

Dann ist es ja kein großer Verlust.

Hey ,wie schlecht kann ein Referenzbuch sein? )

Ganz schön schlecht, wenn sie nicht einmal selber wissen, um welche Sprache es geht. Es gibt kein C/C++. Das wäre wie ein Lehrbuch für Latein/Italienisch. Würdest du ein Buch lesen, dass dies im Titel hat?

Und laut SeppJ funktioniert es ja auch gar nicht so wie ich vorhabe /hatte ?

Wenn du alles änderst wie von DirkB vorgeschlagen, dann würde es schon gehen, dann wäre ja kaum noch etwas wie jetzt. Ich vermutete, dass du solch einen Ratschlag ohne das nötige Hintergrundwissen ohnehin nicht verstehen würdest und riet dir deshalb, dieses erst einmal zu lernen. Anscheinend hatte ich wohl doch recht.

Django2012

@ Kenner der Streambuffer : Hab ich mir angesehen. Sowas in die richtung dachte ich mir bereits, ich habe aber auf eine "einfachere" Lösung gehofft, bzw. das ich vielleicht nur nen kleinen Fehler in meinem PseudoCode habe, oder die "ultimative Funktion" übersehen habe Das das ganze etwas übertrieben ist, dachte ich mir schon, ich hab sowas schonmal umgesetzt in V#KRL, da war es nochmehr Code.

@SeppJ : "Wenn du alles änderst wie von DirkB vorgeschlagen, dann würde es schon gehen, dann wäre ja kaum noch etwas wie jetzt. Ich vermutete, dass du solch einen Ratschlag ohne das nötige Hintergrundwissen ohnehin nicht verstehen würdest und riet dir deshalb, dieses erst einmal zu lernen. Anscheinend hatte ich wohl doch recht."
Das meine C-Kenntnisse jetzt nach knapp 2 Wochen nicht die besten sind, da gebe ich dir recht. Alles andere halte ich für an den Haaren herbeigezogen.

@DirkB : "Weil du dich noch nicht mit Arrays und Zeigern beschäftigt hast.
Hast du denn schon strcpy/strcat nachprogrammiert? Mit Zeigern und mit Arrays?"
... her gilt das gleiche wie für Sepp... Ich weiß wie Zeiger und Arrays funktionieren, die umsetzung in C läuft allerdings noch nicht , das gebe ich zu.

Ähmmm... nachprogrammieren tu ich eingentlich nichts. Ich lese mir ein Kaptiel durch und erstelle dann etwas das ich brauchen kann , oder evtl. mal brauchen könnte. Natrülich benutze ich dabei meist funktionen oder dergleichen aus dem Kapitel, aber meistens brauche ich mehr Zeugs dazu, also werden paar Kapitel übersprungen usw usw.
Bin da evtl. etwas ungeduldig, weil ich normal umfangreiche Programme erstelle und mit " Wir addieren jetzt 2 Zahlen und nehmen es mal 3" nicht viel anfangen kann.

Das Problem ist aber, dass C-Strings nur eine Vereinbarung sind und anders Funktionieren als in den meisten anderen Programmiersprachen.
Arrays verhalten sich in C auch anderes als normale Variablen.

Und gerade das Verständnis vom Zusammenspiel von Zeigern und Arrays ist für die Stringverarbeitung in C enorm wichtig.

Das Verständnis hast du z.Zt nicht. Darum auch deine Fehler.
Und da nützen dir auch keine aus dem Internet zusammen gesuchte Funktionen.
Die haben auch ihre Macken (die du aber nicht erkennen kannst)

Wenn du schon Programmieren kannst, dann besorg dir den K&R (Kernighan Ritchie)

Django2012

Danke Dirk, ich werde mir die Kapitel mit zeiger und Arrays mal genauer reinziehen und den KR besorgen.

Wie schon gesagt... "Strings" sind nicht so mein Ding, da ich das sehr sehr selten brauche, darum habe ich mich auch in anderen Sprachen nicht sooo damit beschäftigt.

Noch ein "ursprüngliche" frage:

Bei meinem Code

struct db{char*s1; char *s2;}test1;

wenn ich jetzt *s1 mit malloc speicher zuweise, z.B.: 20, könnte ich dann mit fgets oder dergleichen "einlesen" in &test1.s1 ? Oder bin ich da vom Grundsatz her total falsch?

Ansonsten, wenn ich total falsch liege... was kann oder wofür wird dann solch eine Struktur mit char Pointern benutzt?

Ps.: @ Sepp... ich wollte hier niemanden auf die Füße treten

SeppJ

Django2012 schrieb:

Bei meinem Code
struct db{char*s1; char *s2;}test1;
wenn ich jetzt *s1 mit malloc speicher zuweise, z.B.: 20, könnte ich dann mit fgets oder dergleichen "einlesen" in &test1.s1 ? Oder bin ich da vom Grundsatz her total falsch?

Noch nicht ganz richtig. Denn &test1.s1 ist die Adresse des Pointers selbst (der selber eine Variable ist und einen Wert hat, den man ändern kann). Du möchtest dahin schreiben, wo der Zeiger hinzeigt. Also schlicht und einfach test1.s1. Das wird dir klarer werden, wenn du dich mit Zeigern und Zeichenketten beschäftigst.

Wie "kenner der streambuffer" aber schon sagt, ist dies eine etwas komische Vorgehensweise. Wenn du mit malloc fest 20 Zeichen holst, kannst du auch gleich viel einfacher ein Array von 20 Zeichen nehmen. Das ist die für Anfänger empfehlenswerte Methode. Der eigentliche Sinn von malloc, die Zahl der Zeichen flexibel festzulegen, wäre in der Umsetzung wesentlich aufwändiger und wäre bei deinem Lernfortschritt jetzt noch zu früh. Es wäre wahrscheinlich auch gar nicht nötig.

Django2012 schrieb:

wenn ich jetzt *s1 mit malloc speicher zuweise, z.B.: 20, könnte ich dann mit fgets oder dergleichen "einlesen" in &test1.s1 ? Oder bin ich da vom Grundsatz her total falsch?

wenn du mit malloc 20 bytes speicher reservierst und die startadresse
(das ist der rückgabewert von malloc im falle einer erfolgreichen reservierung)
in s1 speicherst, dann könntest du

test1.s1 = s1; // test1.s1 nicht &test1.s1 !

schreiben.
erst dann hätte die membervariable s1 deiner struktur diese startadresse gespeichert und erst dann hättest du durch die membervariable s1 zugriff auf die reservierten 20 bytes. diese adresse könntest du an fgets oder an andere funktionen übergeben, das ist richtig.

Django2012 schrieb:

was kann oder wofür wird dann solch eine Struktur mit char Pointern benutzt?

zeiger kann man dafür benutzen, speicher während der laufzeit zu reservieren und die größe dieses speichers während der laufzeit zu ändern(vergrößern, verkleinern).
ob sich ein zeiger in einer struktur befindet oder nicht, ist für die reservierung nicht ausschlaggebend.
man packt gern mehrere variable in eine struktur, wenn man dem programm eine gewisse ordnung geben möchte. das hat oft vorteile wie bessere übersichtlichkeit, bessere wartbarkeit des codes, usw.
z.b. lassen sich alle member einer struktur mit nur einer strukturvariable per zeiger als parameter an eine funktion übergeben.

Django2012

hmmm... und ich dachte schon die S7AWL Pointer sind ein Buch mit 7 Siegeln, das kann ja mit C noch interessant werden.

Evtl. wird mir das ja auch noch klarer, wenn mir jmd. folgendes auf C übersetzen könnte? :

Also in etwa so :

//S7 AWL Pseudo
L P#0.0   // Einen Pointer auf die Adresse  0.0 laden
LAR1   // S7 Pointer werden im Adressregister gespeichert. 

AUF DB[index]          //Datenbaustein mit nummer "index" öffnen
init: schleifenindex   // schleifenzähler  z.b. 10
L 45.5                 //lädt den Wert 45.5
T W[AR1, P#8.0]        // in das Word 8.0 des Datenbausteins "index"
L #typ                 // Typvarialbe z.B. int 2 da mit Word gearbeitet wird
+ar1                   // Pointer erhöhen
L schleifenindex       // schleifenindex wird quasi dekrementiert
loop init             // schleife wird solange ausgeführt bis zähler auf 0

das wäre ne Array initialisierung wobei das Array aus 10 INT werten besteht.
Ich dachte nun, in C würde ich ja mit

int *p1   //pointer definiert
p1 = &Erstes Arrayelement   // zeigt jetzt auf das erste Element ??

aber hier auf das erste Elemnt zugreifen können.
Das zweite Element wäre dann den Pointer um "1" erhöhen also irgendwie mit dem ++ Operator.

Wenn jetzt wie in meinem ursprünglichem Beispiel

struct DB{char *s1; char *s2;}test1;

s1 auf ein(?) char zeigt, dann könnte ich dies mit "&test.S1" adressieren?
Aber die Malloc funktion würde ja wie folgt aussehen: (?)

s1 = (char*) malloc (20)

...also brauch ich bei dem char Pointer aus meiner Struktur eigentlich keinen Adressoperator?

für fgets(&test1.s1.....) brauche ich den Adressoperator, da fgets nen Zeiger will, richtig?

Django2012

@Kenner : hab deinen Beitrag erst jetzt gelesen, da ich mit dem Verfassen des meinigens beschäftigt war

wenn du mit malloc 20 bytes speicher reservierst und die startadresse
(das ist der rückgabewert von malloc im falle einer erfolgreichen reservierung)
in s1 speicherst, dann könntest du

Wäre das dann so :

&s1 = (char*) malloc (20)

?
...sieht mich komisch an....

SeppJ

Nein, deine Syntax stimmt überhaupt nicht. Bitte nicht planlos rumraten.

c.rackwitz schrieb:

Wenn du selber Code schreibst, musst du ihn auch verstehen. Code ist kein Haufen von wahllos zusammengeschmissenen Buchstaben und Zeichen, Code ist Logik pur. Du musst genau wissen, warum du wo und welches Zeichen setzt.

Hier ist ein minimales Beispiel:

#include <stdio.h>
#include <stdlib.h>

int main()
{
  char *string;
  unsigned num_chars;
  puts("Wie viele Zeichen?");
  scanf("%u ", &num_chars);
  if (string = malloc(num_chars + 1)) // +1 für Nullterminierung
    {
      puts("Gib Zeichen ein:");
      fgets(string, num_chars + 1, stdin);
      printf("Folgendes wurde eingegeben (erste %u Zeichen): %s\n", num_chars, string);
    }
  free(string);

  return 0;
}

Bitte versuch jetzt nicht, das Beispiel nach und nach zu modifizieren, bis es zu dem passt, was du hast. Ich verweise nochmals auf obiges, treffendes Zitat von einem früheren Forenmitglied. Lern vernünftig Zeiger und Zeichenketten!
Zeiger und Zeichenketten sind in C nun einmal etwas kompliziert, aber du kommst nicht drumherum. Die lernst du aber nicht aus Internettutorials und auch nicht aus Büchern, deren Autoren das Thema selber nicht verstanden haben. (Das ist kein unnötiger Seitenhieb auf das Buch. J. Wolf hat Zeiger nicht verstanden. Das geht aus den fehlerhaften Beispielen in dem Buch eindeutig hervor.)

Django2012 schrieb:

@Kenner : hab deinen Beitrag erst jetzt gelesen, da ich mit dem Verfassen des meinigens beschäftigt war

wenn du mit malloc 20 bytes speicher reservierst und die startadresse
(das ist der rückgabewert von malloc im falle einer erfolgreichen reservierung)
in s1 speicherst, dann könntest du

Wäre das dann so :
&s1 = (char*) malloc (20)
?
...sieht mich komisch an....

struct TestStruct
{
	char* s1;
};
int main(void)
{
struct TestStruct test_struct;
	char* s1 = malloc(20);
	if(s1 == NULL)
		return 0;
	test_struct.s1 = s1;
	puts("eingabe:");
	fgets(test_struct.s1, 20, stdin);
	printf("deine eingabe: %s\n", test_struct.s1);
	free(s1);
return 0;
}

hier würde man weder malloc, noch zeiger noch strukturen brauchen.
das soll lediglich die syntax zeigen.

Django2012

Danke für beide Beispiele.... Es wird ein bisschen klarer.

Abschließend zu malloc noch eine Frage :

aus der C-Referenz :

void* malloc (size_t size)

in dem Beispiel der C-REfernz dann so ausgeführt :

char * buffer;
buffer = (char*) malloc (20);

Bei Euren Beispielen :
[/code]char* s1 = malloc(20)[/code]
und

string = malloc(num_chars + 1)

...wie ist die Referenz zu verstehen,? Ich les die Dinger glaub ich doch öfter falsch...

ist mein :
[/code]s1 = (char*) malloc (20) [/code]
total daneben=?

SeppJ

Dann ist deine C-Referenz eine C++-Referenz (wo es das malloc auch gibt, auch wenn man es dort nie benutzt) oder will aus anderen Gründen zu C++ kompatibel sein^*. In C braucht man diesen Cast nicht (wegen der anderen Regeln für Konvertierungen zwischen Pointertypen). Das einzige Argument für den Cast ist, dass man dann den C-Code auch mit einem C++-Compiler übersetzen kann. Was man ohnehin nicht tun sollte. Er ist zwar nicht direkt falsch, kann aber ein paar Probleme verursachen und zu sehr schwer zu findenden Fehlern führen. Meine Empfehlung: Weglassen.

^*: Da die ersten Treffer bei Google allesamt zu C++-Referenzen führen, nehme ich mal an, dass ersteres der Fall ist. Das ist auch ok, diese Referenzen zu benutzen. Die versuchen in der Regel im Teil der C-Bibliothek auch kompatibel zu C zu bleiben und dort keine C++-Sprachmittel zu verwenden. Aber natürlich sind die Beispiele immer noch in erster Linie für C++ gedacht, was dann eben manchmal zu subtilen Unterschieden wie diesem hier führt. Es sind eben doch verschiedene Sprachen, auch wenn sie wegen des Namens und der Geschichte oft zusammen geworfen werden.

Django2012

Guten morgen Ihr zwei

Also, ich hab mir jetzt von K&R C the Programming Languga 2nd Edition und von einem Herrn Schellong "Moderne C Programmierung - Kompendium & Referenz " besorgt.
Ich denke mal das diese beiden Bücher mir doch weiterhelfen sollten.

Nochmals habe ich jedoch eine Frage zu den "Referenzen".
Wie Sepp schon festgestellt hat, war das gestern aus der C++Refernce . My fault.

Also gehen wirs mal an :

wenn ich eine selbsterstellte Funktion habe, z.B.:

void set_axis(struct E6Pos *pt, int *status, int *turn)

so muss, ich beim Aufruf wie folgt übergeben : (habs probiert, anders gehts auch nicht)

bla bla
     set_axis(&Home_Pos, &act_status, &act_trun)

wobei Home_Pos ne Struct vom Typ E6Pos ist.

Also da check ich das mit dem Adressoperator.

So, jetzt aus der Referenz: (fgets)

char *fgets(char *s, int n, FILE *stream)

Hier funktioniert das ganze , z.B. so:

char  Data[80]
fgets(Data, sizeof(Data), stdin);

Hier brauch ich keine Adressoperator...why? Weil Data festgelegt ist?

hingegen bei folgender Funktion (fwrite)

size_t fwrite(const void *buffer, size_t groesse, size_t anzahl,
                 FILE *stream)

habe ich folgendes Beispiel angesehen :

int main(void)
{
   FILE *stream;
   long list[NUM];  /*NUM ist als 100 definiert
   int numwritten;

   stream = fopen("myfile.dat", "w+b");

              /* assign values to list[]                                      */

   numwritten = fwrite(list, sizeof(long), NUM, stream);
   printf("Number of items successfully written : %d\n", numwritten);
   return 0;

Ok... list ist klar, size of ist klar, NUM?? Naja dazu komme ich noch, stream ist auch klar.

Jetzt ein Beispiel aus dem (mittlerweile auch von mir) verhassten Buch : (Galileo...)

struct {
   char name[20];
   char vornam[20];
   char wohnort[30];
   int alter;
   int plz;
   char Strasse[30];
} adressen;

FILE *quelle;

strcpy(adressen.name, "Barack");
strcpy(adressen.vornam, "Obama");
strcpy(adressen.wohnort, "Washington D.C");
adressen.alter = 55;
adressen.plz = 23223;
...
if((quelle=fopen("adres.dat", "w+b")) == NULL)
...
fwrite(&adressen, sizeof(struct adressen), 1, quelle);

??? Wieso braucht er jetzt den Adressoperator? bei dem sizeof das "struct" nimmt er im nachfolgenden Beispiel nicht mehr her. Aber warum die 1? Bei dem andren Beispiel wurde NUM angegeben (da war das ganze ein Array, mit 100 longs) ... Also vermute ich 1.) Beispiel hat 100 Long einträge mit der größe von long geschrieben, und das Galileo Beispiel will nur einmal die Struct schreiben. OK

Aber wie zum Teufel ist jetzt so ne Referenz zu lesen?
Bei einer selbsterstellen funktion die nen Pointer in der Parameterliste enthält brauch ich zum zu weisen den "&".
Wenn ich mir jetzt die Referenz so ansehe... und dann die Beispiele.... Ich habs auf probiert, für die Struct gings mit dem "&". Wahh...

Problem mit &quot;schreiben&quot; in Struct

Problem mit "schreiben" in Struct