free("den return wert einer funktion")

[MasterCounter]

dann returned die funktion doch nichts mehr oder?

[Bashar]

Dann musst du es nach dem return (beim Aufrufer) freigeben ...

[MasterCounter]

also so dann oder wie:

b=funktion();
//mach irgendwas mit b
free(b);

[leo aka qsch]

du kannst free natürlich auch in der funktion benutzen die deine funktion aufgerufen hat

/EDIT da hab ich wohl ein bisschen zu spät gepostet

[MasterCounter]

also so dann oder wie:

b=funktion();
//mach irgendwas mit b
free(b);

[leo aka qsch]

warum probierst du es nicht aus?

denn rueckgabewert der Funktion muestest dann natuerlich noch aendern

[supertux]

Da ist ja ein Fehler

int* funktion(size_t size)
{
    int* b = malloc(sizeof(int)*size);
    if(!b) return NULL;
    ... /* mach was mit *b und liefere den Pointer zurück */
    return b;
}

...

void foo()
{
    int* x = funktion(10);
    ...
    /* Speicher freigeben */
    free(x);
}

[chille07]

wo genau liegt das problem?

[pointercrash**]

Das Problem liegt darin, daß es sowieso nicht so funktionieren kann.

malloc() liefert einen Pointer zurück, folglich kann die Funktion keinen Integer zurückliefern, ohne daß sich zumindest der Compiler drüber aufregt.

Dem free(*xx) muß man natürlich den Rückgabe wert von malloc() übergeben, aber dann ist der Speicher eigentlich echt wieder frei.

[chille07]

der rückgabewert wird doch zurückgegeben.
malloc gibt ein "void *" zurück.
x erhält den rückgabewert von malloc, welcher auf den allocierten speicherplatz zeigt.
free(x) sollte also funktionieren.
die belegung auch.
WO LIEGT DAS PROBLEM?

was du vielleicht versuchen könntest:

int *x;
x=function(10);

mfG (c)h

[chille07]

#include<malloc.h>

gemacht?

[SirLant]

Ich versteh das Problem nicht wirklich, der Kern ist doch einfach free (malloc (1000)); und ob da noch diverse Dinge dazwischen gemacht werden ist doch egal.
Du kannst den Speicher löschen wo du willst (bis auf ein paar Ausnahmen je nach OS), so lange du noch einen Zeiger auf diesen Bereich hast.

[Bashar]

chille07 schrieb:

#include<malloc.h>

gemacht?

malloc ist in ANSI-C in stdlib.h

[supertux]

chille07 schrieb:

wo genau liegt das problem?

int funktion();

ist ein int aber gibt ein (???)* Zurück (ein unbekanntest Pointer, vielleicht int*)

edit:

pointercrash() schrieb:

Das Problem liegt darin, daß es sowieso nicht so funktionieren kann.

malloc() liefert einen Pointer zurück, folglich kann die Funktion keinen Integer zurückliefern, ohne daß sich zumindest der Compiler drüber aufregt.

ganau das ist der fehler.

[supertux]

chille07 schrieb:

WO LIEGT DAS PROBLEM?

Der Rückgabetyp der Funktion ist nicht gleich wie die Rückgabe. Das ist ein Problem. Ob das nur einw Warnung des Compilers erzeugt oder nicht, ist nicht die Frage, denn es würde funktionieren, ist aber trotzdem falsch.

[chille07]

supertux schrieb:

Da ist ja ein Fehler

int* funktion(size_t size)
{
    int* b = malloc(sizeof(int)*size);
    if(!b) return NULL;
    ... /* mach was mit *b und liefere den Pointer zurück */
    return b;
}

...

void foo()
{
    int* x = funktion(10);
    ...
    /* Speicher freigeben */
    free(x);
}

der rückgabetyp von function ist doch "int*" !!!

[chille07]

wie wärs mit:

int* b = (int*)malloc(sizeof(int)*size);

?

[leo aka qsch]

so viel diskutieren fuer so ein einfaches Problem

malloc gibt einen typenlosen zeiger zurueck (void
einfach expliziet auf int * casten und zeiger auf einen int returnen

free erwartet wieder einen void zeiger also ist hier kein cast mehr noetig

das hier funktioniert ohne probleme:

void parent_func()
{
   int *f = func();
   // verwende f
   free(f);
}

int *func()
{
    int *i = (int *) malloc(sizeof(int));
    // verwende i
    return i;
}

dies waehre genau das selbe

void parent_func()
{
   int *f = (int *) func();
   // verwende f
   free(f);
}

void *func()
{
    void *i = malloc(sizeof(int));
    // verwende i
    return i;
}

ich hoffe das Problem ist jetzt gelöst

[supertux]

chille07 schrieb:

supertux schrieb:

Da ist ja ein Fehler

int* funktion(size_t size)
{
    int* b = malloc(sizeof(int)*size);
    if(!b) return NULL;
    ... /* mach was mit *b und liefere den Pointer zurück */
    return b;
}

...

void foo()
{
    int* x = funktion(10);
    ...
    /* Speicher freigeben */
    free(x);
}

der rückgabetyp von function ist doch "int*" !!!

tja, das war meine Korrektur. Schau Post 001, schau dir das erste Post an.

malloc gibt einen typenlosen zeiger zurueck (void
einfach expliziet auf int * casten und zeiger auf einen int returnen

Nur unter C++ muss man casten, unter C brauchst du nicht zu casten.

[leo aka qsch]

supertux schrieb:

malloc gibt einen typenlosen zeiger zurueck (void
einfach expliziet auf int * casten und zeiger auf einen int returnen

Nur unter C++ muss man casten, unter C brauchst du nicht zu casten.

ich bin mir sogar sehr sicher das man casten muss
der compiler kann keine impliziete Typenumwandlung von void * to int * durchfuehren

glaubst du wirklich das man nur unter c++ casten muss..?