1. Dashboard
  2. Forum
    1. Unerledigte Themen
  3. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team-Mitglieder
    4. Trophäen
    5. Mitgliedersuche
  4. Tutorial Bereich
  • Anmelden
  • Registrieren
  • Suche
Dieses Thema
  • Alles
  • Dieses Thema
  • Dieses Forum
  • Seiten
  • Forum
  • Lexikon
  • Erweiterte Suche
  1. Informatik Forum
  2. Webmaster & Internet
  3. Entwicklung

warum geht das?!

  • sommeralex
  • 27. Juli 2005 um 17:57
  • Unerledigt
  • sommeralex
    11
    sommeralex
    Mitglied
    Punkte
    1.325
    Beiträge
    188
    • 27. Juli 2005 um 17:57
    • #1

    Hallo :winking_face: - lasst euch von den paramtern nicht abschrecken, darum gehts hier nämlich nicht..

    struct c *create_config(interval * val, float limit, short alarm_mode, short locked_mode){

    struct c config = {val, limit, alarm_mode, locked_mode};
    return &config;
    }

    int main(){

    struct c *p_config = create_config(val_1, 2.3, 2, 3);


    short lm = p_config->locked_mode;
    printf("%d", lm);

    }

    ich dachte, wenn ich variabeln/structs während der laufzeit initialisiere, benötige ich malloc. dennoch liefert mein programm die richtige zahl, nämlich 3.

    noch eine frage:

    wenn ich in java auf ein objekt zeige, existiert es, solange ich darauf zeige. wenn ich in C auf ein objekt zeige, und meinen zeiger de-referenziere, existiert das objekt weiter (obwohl ich nicht mehr darauf zugreifen kann) um es vom speicher zu entfernen, muss ich zuerst free() anwenden - stimmt das?

  • sommeralex
    11
    sommeralex
    Mitglied
    Punkte
    1.325
    Beiträge
    188
    • 27. Juli 2005 um 18:31
    • #2

    jetzt hab ich sicherheitshalber meine funktion mit malloc erzeugt.

    ------- code kann 1:1 übernommen/compiliert werden -------

    struct c{

    /*2c*/ float limit;
    /*3c*/ short alarm_mode;
    /*4c*/ short locked_mode;

    };

    struct c *create_config(float limit, short alarm_mode, short locked_mode){

    //
    struct c *poi;
    struct c config = {limit, alarm_mode, locked_mode};
    poi = (struct c *)malloc(sizeof(struct c));
    poi = &config;

    return poi;
    }


    int main(void){

    struct c *p_config = create_config(2.3, 2, 78);

    short lm = p_config->locked_mode;
    printf("%d\n", lm);

    lm = p_config->locked_mode;
    printf("%d\n", lm);

    lm = p_config->locked_mode;
    printf("%d\n", lm);

    return 0;
    };


    ------- code ende -------

    aber das SCHLIMME IST FOLGENDES:
    die ausgabe ist beim ersten printf 78 (richtig)
    die ausgabe beim zweiten printf wird 18

    wie kann das sei?

  • volatile_void
    3
    volatile_void
    Mitglied
    Punkte
    45
    Beiträge
    9
    • 27. Juli 2005 um 18:50
    • #3
    Zitat von sommeralex


    ich dachte, wenn ich variabeln/structs während der laufzeit initialisiere, benötige ich malloc. dennoch liefert mein programm die richtige zahl, nämlich 3.


    Das ist hier nur zufällig so.
    Der Zeiger p_config zeigt auf die bereits freigegebene config struct am Stack. Da dieser Speicherbereich aber zwischenzeitlich noch nicht anders verwendet wurde, stehen dort noch die Werte, die du zugewiesen hast.
    Wenn du aber dazwischen noch einen Funktionsaufruf z.B von create_config(...) machst, stehendort wahrscheinlich vollkommen andere Werte.
    Probier mal folgendes:

    int main(){

    struct c *p_config = create_config(val_1, 2.3, 2, 3);

    (void) create_config(val_1, 4.0, 5, 6);

    short lm = p_config->locked_mode;
    printf("%d", lm);

    }

    Jetzt sollte was anderes herauskommen, weil der Speicherbereich mit anderen Werten überschrieben wurde.

    Zitat von sommeralex


    wenn ich in java auf ein objekt zeige, existiert es, solange ich darauf zeige.


    Jain. Genau genommen existiert es auch noch weiter, wenn du nicht mehr darauf zeigst. Erst wenn es dann von der Garbage Collection entfernt wurde, ist der Speicher endgültig freigegeben.

    Zitat von sommeralex


    wenn ich in C auf ein objekt zeige, und meinen zeiger de-referenziere, existiert das objekt weiter (obwohl ich nicht mehr darauf zugreifen kann) um es vom speicher zu entfernen, muss ich zuerst free() anwenden - stimmt das?


    Ja.

  • volatile_void
    3
    volatile_void
    Mitglied
    Punkte
    45
    Beiträge
    9
    • 27. Juli 2005 um 19:00
    • #4

    struct c *create_config(float limit, short alarm_mode, short locked_mode){

    //
    struct c *poi;
    struct c config = {limit, alarm_mode, locked_mode};
    poi = (struct c *)malloc(sizeof(struct c));
    poi = &config; // falsch!
    // damit zeigt poi auf den Speicherbereich von config!
    // Dieser Speicherbereich wird ja am ende der funktion freigegeben!

    return poi;
    }

    richtig wäre z.B:

    struct c *create_config(float limit, short alarm_mode, short locked_mode){

    //
    struct c *poi;
    poi = (struct c *)malloc(sizeof(struct c));

    poi->limit = limit;
    poi->alarm_mode = alarm_mode;
    poi->locked_mode = locked_mode;

    return poi;
    }

    Zitat von sommeralex


    wie kann das sei?


    Wegen dem obengenannten Fehler überschreibt printf den Speicherbereich, auf den du mit p_config zeigst.

  • sommeralex
    11
    sommeralex
    Mitglied
    Punkte
    1.325
    Beiträge
    188
    • 27. Juli 2005 um 19:19
    • #5

    ..jetzt kenn ich mich aus.. (ich wills nicht verschrein) :winking_face:

    ->das heisst, wenn ich in meiner funktion zwei pointer deklariere, beispielsweise so:

    pointer A = {Parameter} [explizit OHNE malloc]
    pointer B = [explizit MIT malloc]

    und dann B = A mache
    und B als Wert der Funktion zurückgebe,

    GEHT DAS AUCH NICHT - ich hoffe, diese analogie ist richtig.

    vielen dank für deine hilfe!

  • Maximilian Rupp 27. Dezember 2024 um 12:06

    Hat das Thema aus dem Forum Programmieren nach Entwicklung verschoben.

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!

Benutzerkonto erstellen Anmelden

Benutzer online in diesem Thema

  • 1 Besucher

Rechtliches

Impressum

Datenschutzerklärung