free("den return wert einer funktion")

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..?

supertux

leo aka qsch schrieb:

ich bin mir sogar sehr sicher das man casten muss

muss man nicht

/* test.c */
#include <stdlib.h>

void* foo();
void a();

void* foo()
{
    return malloc(5);
}

void a()
{
    int* a = foo();
    char* q = foo();
    size_t* b = foo();
    free(b);
    free(q);
    free(a);
}

Wenn ich casten müsste, würde der Compiler meckern oder eine Warnung bringen.

rex@supertux:~> gcc -c test.c -ansi
rex@supertux:~>

Wie du siehst, der Compiler bringt gar keine Warnung. Wäre das aber C++

rex@supertux:~> cp test.c test.cpp
`test.c' -> `test.cpp'
rex@supertux:~> g++ -c test.cpp -ansi
test.cpp: In function `void a()':
test.cpp:13: error: invalid conversion from `void*' to `int*'
test.cpp:14: error: invalid conversion from `void*' to `char*'
test.cpp:15: error: invalid conversion from `void*' to `size_t*'
rex@supertux:~>

Wie du siehst, man muss in C++ casten, in C nicht.

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

Bis heute musste ich nie mit C casten.

chille07

EDIT: ---

EDIT2: cls; hab die "Seite 3" übersehen

free(&quot;den return wert einer funktion&quot;)

free("den return wert einer funktion")