Speicher mit malloc wird nicht bleiben außerhalb Funktionsumfang?

Hallo,

Ich bin ein bisschen neu in C-s malloc-Funktion, sondern von dem, was ich weiß, sollte es speichern den Wert in den heap, so dass Sie verweisen können es mit einem Zeiger aus, die außerhalb des ursprünglichen Umfang. Erstellt habe ich ein test-Programm, das ist, dies zu tun, aber ich erhalte immer den Wert 0, nach dem ausführen des Programms. Was mache ich falsch?

int f1(int * b) {
 b = malloc(sizeof(int));
 *b = 5;
}

int main() {
 int * a;
 f1(a);
 printf("%d\n", a);
 return 0;
}

InformationsquelleAutor der Frage PM. | 2010-03-25

c malloc

Ja! a ist durch Wert übergeben so dass der Zeiger b in Funktion f1 werden lokale..
entweder zurück b,

int *f1() {
    int * b = malloc(sizeof(int));
    *b = 5;
    return b;
}

int main() {
    int * a;
    a = f1();
    printf("%d\n", *a);
    //keep it clean : 
    free(a);
    return 0;
}

oder pass a's Adresse

int f1(int ** b) {
    *b = malloc(sizeof(int)); 
    **b = 5;
}

int main() {
    int * a;
    f1(&a);
    printf("%d\n", *a);
    //keep it clean : 
    free(a);
    return 0;
}

InformationsquelleAutor der Antwort raj

9

Es sieht aus wie du bist Missverständnis ein wesentlicher Teil, wie C funktioniert - nämlich, dass es ein "pass-by-value' - Sprache. Um für main() wissen über den Speicher, den Sie vergeben, müssen Sie es wieder aus. Der folgende code machen, was man will:
```
int f1(int **b)
{
    *b = malloc(sizeof(int));
    **b = 5;
}

int main(int argc, char **argv)
{
    int *a;
    f1(&a);
    printf("%d\n", *a);
    return 0;
}
```
Gibt es ein paar Unterschiede zwischen diesem code und Ihre; ersten, die Signatur von f1() geändert hat, so dass es zurückgeben kann, das Ergebnis der malloc() Anruf in die übergebene Zeiger. Als Nächstes erfolgt der Aufruf zu f1() geändert wurde, übergeben Sie die Adresse von a eher als a selbst - wichtig, wenn Sie wollen, dass es "gefüllt", indem f1()so zu sprechen. Endlich, die printf() im main() wurde geändert, um Druck aus dem Spitzen-Wert eher als der Zeiger selbst.

InformationsquelleAutor der Antwort Carl Norum
6

Den Speicher selbst besteht, aber es Lecks, weil Sie nicht die Bereitstellung der zugewiesenen Zeiger auf den Anrufer. Auch, Sie drucken a wenn Sie sollten Druck *a. Schließlich bist du nicht wieder einen int aus f1.

Versuchen:
```
void f1(int **b) {
 *b = malloc(sizeof(int));
 **b = 5;
}

int main() {
 int *a;
 f1(&a);
 printf("%d\n", *a);
 free(a);
 return 0;
}
```
InformationsquelleAutor der Antwort Matthew Flaschen
5

Lässt annehmen, dass Sie einen Wert zuweisen, der NULL ein, bevor Sie die Funktion aufrufen f1. Jetzt ist der Weg f1 definiert ist, dauert es seine argument(Zeiger auf ein int) von Wert. Das ist b wird eine weitere variable vom Typ int * wird kopieren von a. So b auch einen Wert haben wird, der NULL. Jetzt in f1 Sie den Wert ändern, indem b durch zuweisen der Adresse des Speichers, der dynamisch mit malloc. Können sagen, dass die Speicher-Adresse ist 0x123. Als Ergebnis dieser Zuordnung b geändert hat, seinen Wert aus NULL zu 0x123 aber a(in main) weiterhin zu halten NULLda sich b nicht ändern awie Sie sind zwei getrennte Variablen. Als Ergebnis dieser, wenn Sie zurückkehren aus der Funktion f1 eines wird unverändert bleiben.

Gibt es 2 Wege, diese zu lösen. Sie können die Funktion f1 Gegenzug den Wert des geänderten b und dann weisen Sie es zurück zu einem in main und zwei, die Sie übergeben können, die eine von-Adresse, so dass änderungen in f1 auf eine in main zu.
```
//f1 now returns the value of b.
int* f1() {
 int *b = malloc(sizeof(int));
 *b = 5;
 return b;
}

int main() {
 int *a = NULL;
 a = f1(); //assign the return value of f1 to a.
 printf("%d\n", *a); //prints 5...not its *a not just a.
 return 0;
}
```
.
```
//f1 now takes the address of a. 
void f1(int **b) {
 *b = malloc(sizeof(int)); //you are actually altering a indirectly.
 **b = 5; 
}

int main() {
 int *a = NULL;
 f1(&a); //now pass the address of a to f1.
 printf("%d\n", *a); //prints 5...not its *a not just a.
 return 0;
}
```
InformationsquelleAutor der Antwort codaddict
0

Die Adresse int *b wird gelöscht, wenn die Funktion zurückkehrt. Um es zu retten, Sie verwenden müssen, um einen Zeiger an einen Zeiger
```
int f1(int ** b) {
   *b = malloc(sizeof(int));
   **b = 5;
}
```
InformationsquelleAutor der Antwort Phong
0

Dein problem ist eigentlich nicht mit malloc, sondern vielmehr die Tatsache, dass Sie vorbei sind der Wert, den der Zeiger aktuell hält, anstatt die Adresse. Versuchen Sie Folgendes:
```
int f1(int ** b) {
    *b = malloc(sizeof(int)); 
    **b = 5;
}

int main() {
    int * a;
    f1(&a);
    printf("%d\n", *a);
    return 0;
}
```
Durch die übergabe des Zeiger-Wert, wie Sie waren, gab es keine Möglichkeit für den Wert malloc erstellt werden gespeichert in die Zeiger.

InformationsquelleAutor der Antwort Dusty

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.