C: Zeiger auf Char in einer Struktur

[Sector1379]

Hallo zusammen,

ich habe folgendes Problem was ich am besten in einem kleinen Beispiel Code erkläre weil das ganze Prog zu posten und zu erklären dauert zu lange.

Erst mal der Code:

#include <stdio.h>
#include <string.h>

typedef struct{

char *satz;

}Satz_t;

int main(void){

  Satz_t ptr;
  char string[100]; 
  
  printf("Schreib einen Satz:");
  fgets(string,99,stdin);
  strcpy(ptr.satz, string);

   printf("%s", ptr.satz);

}

Also wie man oben sieht will ich das eingelesene kopieren in den Char Zeiger der Struktur. Nun kommt es dabei immer wieder zu einem Speicher Fehler.

Könnte mir vielleicht jemand erklären wie ich das hinbekomme das der eingelesene Satz ohne Fehler in dem Char Zeiger kopiert wird ??

[Liberty]

Moin,

ich bin schon 'ne Weile aus C wieder raus, aber irgendein unbestimmtes Gefühl sagt mir, dass Du in Deiner Struktur überhaupt keine echten Speicher für den zu kopierenden String hast, Deine Struktur enthält ja nur einen Pointer (also eine Adresse auf einen String).
Wenn Du in Deiner Struktur den String ablegen willst, dann musst Du schon ein Char-Array (char[] MeinString) verwenden.

So long,
Liberty

P.S.:
Wenn Du Dich nur falsch ausgedrückt hast und wirklich nur den Zeiger brauchst, dann musst Du dem Zeiger in Deiner Struktur die Adresse des Originals zuweisen und das geht - lass mich lügen - über:

ptr.satz = &string

P.P.S.:
ABer wie gesagt, praktisch arbeite ich im Moment nicht mit C, also alles mit Vorsicht genießen

[sticky bit]

Liberty hat schon recht, du hast nur einen Zeiger in der Struktur ohne einen Speicherbereich dahinter zu haben. Also entweder gleich in der Struktur einen Vektor fester Länge definieren oder für den Zeiger in der Struktur erst mal Speicher anfordern.

Wenns dir aber nur ums umkopieren geht, dann ist ptr.satz = &string falsch. Das kopiert die Adresse von string aber nicht den Wert. Und der Wert ist der Zeiger auf den Vektor. ptr.satz = string wäre das richtige dafür...

[Liberty]

Ups, hab' vergessen, dass string ja sowieso schon ein Zeiger ist, de nochmal mit dem &-Operator zu behandeln würde ja die Adresse des Pointers und nicht die Adresse des Arrays liefern, richtig?

Ich muss unbedingt mal wieder etwas mehr C machen...

[sticky bit]

Ups, hab' vergessen, dass string ja sowieso schon ein Zeiger ist, de nochmal mit dem &-Operator zu behandeln würde ja die Adresse des Pointers und nicht die Adresse des Arrays liefern, richtig?

Richtig. Das würde die Speicheradresse (also eigentlich nur ne Zahl) zu der Stelle liefern an welcher die Speicheradresse für den Vektor liegt (wiederum nur ne Zahl), die muss schliesslich auch irgendwo im Speicher vorliegen...

[Sector1379]

Super vielen dank für eure hilfe. Ich werde dann erst mal ein nettes malloc einsetzen. Ich denke dann wirds wohl klappen.

[Sector1379]

ich habe nochmal eine Frage zum speicher wieder freigeben.

Ich habe jetzt folgendes gemacht, also wieder anhand des Beispiels:

#include <stdio.h>
#include <string.h>

typedef struct{

char *satz;

}Satz_t;

int main(void){

  Satz_t *ptr;
  char string[100]; 
  
  ptr = (Satz_t*) malloc( 100 *sizeof(Satz_t));
  printf("Schreib einen Satz:");
  fgets(string,99,stdin);
  
  ptr.satz = (char*) malloc(100 * sizeof(char));
  strcpy(ptr.satz, string);

   printf("%s", ptr.satz);

}

Das klappt auch alles aber wie kann ich nun den ganzen Speicher den ich reserviert habe wieder freigeben ????????????

Muss ich nicht in einer for Schleife zunächst erst mal alle satz elemente frei machen ??????

[sticky bit]

Wieso Schleife? Ich sehe da in deinem Code keine Schleife?

Du forderst genau konstant zwei Speicherbreiche an, einmal ptr und einmal ptr.satz, die solltest du eigentlcih ohne weiteres so auch wieder freigeben können. Allerdings in dem Fall in umgekehrter Reihenfolge zum Anfordern, weil ptr.satz ja in ptr liegt und damit weg sein könnte wenn du ptr freigibst, wenn ptr.satz (der Zeiger nicht der Speicherbereich) aber weg is kannst du den Speicherbereich natürlich nimmer freigeben ohne den Zeiger...

Aber ansonsten seh ich kein Problem. Hast dus schon mal versucht? Wenn ja wie und was ist passiert?

[Sector1379]

Wieso Schleife? Ich sehe da in deinem Code keine Schleife?

Du forderst genau konstant zwei Speicherbreiche an, einmal ptr und einmal ptr.satz, die solltest du eigentlcih ohne weiteres so auch wieder freigeben können. Allerdings in dem Fall in umgekehrter Reihenfolge zum Anfordern, weil prt.satz ja in prt liegt und damit weg sein könnte wenn du prt freigibst, wenn ptr.satz (der Zeiger nicht der Speicherbereich) aber weg is kannst du den Speicherbereich natürlich nimmer freigeben ohne den Zeiger...

Aber ansonsten seh ich kein Problem. Hast dus schon mal versucht? Wenn ja wie und was ist passiert?

Hi Sticky

ich meinte das so und ich denke das willst du mir auch damit sagen (hoffe ich)

#include <stdio.h>
#include <string.h>

typedef struct{

char *satz;

}Satz_t;

int main(void){

  Satz_t *ptr;
  char string[100]; 
  
  ptr = (Satz_t*) malloc( 100 *sizeof(Satz_t));
  printf("Schreib einen Satz:");
  fgets(string,99,stdin);
  
  ptr.satz = (char*) malloc(100 * sizeof(char));
  strcpy(ptr.satz, string);

   printf("%s", ptr.satz);

   for(i=0; i <= size; i++)
    free(ptr[i].satz[i]);

   free(ptr);


}

Und dabei kommt es aber zu einem Compiler fehler.

[Sector1379]

So ich habs:

also so mache ich jetzt die for schleife und es klappt wunderbar.

for(i=0; i <= size; i++)
    free(ptr[i].satz);

   free(ptr);

Danke für eure Hilfe

[sticky bit]

Ah OK, ich hab übersehehn, dass du ja quasi 100 deiner Strukturen anlegst. Klar, dann musst du erst mal in allen 100 den Speicherbreich für den Satz freigeben. Aber nur wenn du ihn auch angefordert hast, du hast das aber nur bei der ersten Struktur.
Und warum machst du überhaupt 100 Strukturen, wenn du dann eh nur die erste benutzt?
Bin grad verwirrt was das jetzt überhaupt sein soll?

[RapidMax]

Du müsstes erstmal erklären was du erreichen willst. Geht es nur um das einlesen und wieder ausgeben, würde das hier reichen:

int main() {
    char string[100];    /* Speicherplatz auf dem Stack für 100 Zeichen reserviert */
    printf("Schreib einen Satz: ");
    fflush(stdout);      /* damit der text sicher geschrieben wird */
    fgets(string, sizeof(string), stdin);  /* fgets() berüchsichtigt bereits das NUL am Ende */
    puts(string);        /* Keine aufwändige Format-Strings, dafür aber mit New-Line */
    return 0;
}

Willst du dynamisch speicher allozieren um z.B. eine Liste von Zeilen einzulesen, berücksichtige bitte, dass malloc() auch NULL zurückgeben kann, wenn kein Speicher mehr vorhanden ist:

int main() {
    char *string;    /* Speicherplatz auf dem Stack für einen Pointer auf String reserviert */
    string = (char*)calloc(100, sizeof(char));  /* Speicherplatz auf dem Heap für 100 Zeichen reserviert */
    if (string == NULL)
        return 1;    /* Fehler, kein Speicher mehr! */
    ....
    free(string);    /* Speicherplatz wieder
}

[anda_skoa]

Wenn du den String später nicht mehr erweiterst, kannst du das malloc auch mit der tatsächlichen Länge machen (siehe strlen), bzw strdup zum erzeugen einer Kopie benutzen

Ciao,
_