Malloc und Void-Zeiger

Studiere ich diese malloc-Funktion und ich könnte etwas Hilfe gebrauchen:

static void *malloc(int size)
  {
        void *p;

        if (size < 0)
                 error("Malloc error");
        if (!malloc_ptr)
                 malloc_ptr = free_mem_ptr;

        malloc_ptr = (malloc_ptr + 3) & ~3;     /* Align */

        p = (void *)malloc_ptr;
        malloc_ptr += size;

        if (free_mem_end_ptr && malloc_ptr >= free_mem_end_ptr)
                 error("Out of memory");

        malloc_count++;
        return p;
 }

Ich weiß, dass die malloc-Funktion reserviert Speicher Platz für alle geben, wenn genügend Arbeitsspeicher vorhanden ist, aber die Zeilen, die ich nicht verstehe sind:

p = (void *)malloc_ptr;
malloc_ptr += size;

Wie kann es zeigen Sie auf einen beliebigen Datentyp wie das? Ich kann einfach nicht verstehen, dass void-Zeiger oder seine Lage.

HINWEIS: malloc_ptr ist ein unsigned long

Dieser code enthält die Annahme, dass ein Zeiger auf unsigned long (d.h. malloc_ptr) kann auch auf jedes andere Objekt, von einer Ausrichtung der Sicht. Diese Annahme ist nicht immer erfüllt (zum Beispiel, auf einigen Systemen kann es nicht in der Lage sein, auf long double Objekte).
Der code wird davon ausgegangen, dass kein Typ hat eine strengere Ausrichtung Anforderung als eine 4-byte-Ausrichtung. Den code nicht zeigen, wie free_mem_ptr und free_mem_end_ptr initialisiert werden. Es spielt keine NULL zurück, wenn dort kein Platz mehr ist. Wenn die Funktion error() gibt, dann bricht die Hölle Los.

InformationsquelleAutor morcillo | 2012-12-25

  1. 5

    Dem Grund, es gibt einen void-Zeiger ist, weil es keine Ahnung hat, was Sie sind, zuweisen von Speicherplatz für die malloc nennen. Alles was Sie kennt ist der Raum, den Sie angefordert. Es ist bis zu Ihnen oder Ihrem compiler, um zu entscheiden, was füllt den Speicher. Der void-Zeiger ist der Speicherort ist in der Regel implementiert als verkettete Liste, um die Integrität und wissen, welche Werte der Speicher sind kostenlos, das ist überraschend bleiben in der free Funktion.

    aber Woher weiß er, wie viel Platz zu reservieren? wie sieht es mit der Größe? Ich weiß nur nicht sehen, es. Zum Beispiel habe ich ein struct mit 8 ints 3 chars und 1 float, genannt mystruct, und in der Theorie sollte es reserviert Speicher Platz für so viel, aber ich kann einfach nicht verstehen, wie
    In diesem Fall würden Sie wahrscheinlich verwenden Sie die sizeof - Betreiber, der würde bestimmen Sie die richtige Größe in bytes benötigt, um richtig zuordnen, struct deklariert.
    Ich weiß, das sizeof ist, aber was ich nicht verstehe ist, wie man es macht, um Speicherplatz im Arbeitsspeicher. malloc_ptr hat die Größe, der Typ, aber wie wird p = (void *)malloc_ptr wissen zu reservieren, 8 Byte oder 2 Byte oder 152 bytes? ist das casting für die malloc-Funktion, die es funktionieren lässt? (my_struct *)malloc(sizeof(my_struct))??
    In diesem Fall, die Funktion einfach weist der Zeiger auf das, was ich bin, davon ist eine Struktur, die als eine Speicher-Adresse. Dann dehnt es die Größe von int, die Sie als parameter übergeben und damit "verlängert" die Speicherreservierung durch size bytes zurückgeben, die Sie den führenden Zeiger auf diese Menge Speicher.
    Ich danke Ihnen sehr. Nun das Konzept ist klarer in meinem Kopf. Ich werde weiter zu studieren. Schon gab Sie einen Scheck für die richtige Antwort ... hoffe das ist ein gutes Weihnachtsgeschenk.

    InformationsquelleAutor squiguy

  2. 2

    Dies ist die Umsetzung von malloc, so ist es erlaubt, Dinge zu tun, wäre nicht legitim sein, in einem regulären Programm. Insbesondere wird der nutzen der Implementierung-definiert die Konvertierung von unsigned long zu void *. Programm-Initialisierung setzt malloc_ptr zu den numerische Adresse einen großen block von nicht zugewiesenen Speicher. Dann, wenn Sie Sie bitten, für eine Belegung, malloc macht ein Zeiger aus dem aktuellen Wert der malloc_ptr und erhöht malloc_ptr durch die Anzahl der bytes, die Sie verlangt. So, das nächste mal Sie anrufen malloc wird es wieder einen neuen Zeiger.

    Dies ist über die einfachste mögliche Umsetzung malloc. Insbesondere erscheint es nicht immer die Wiederverwendung freigegebenen Speicher.

    InformationsquelleAutor zwol

  3. 1

    Malloc ist wieder ein Zeiger für ein Stück völlig unstrukturiert, Wohnung Speicher. Das (void *) - Zeiger bedeutet, dass Sie keine Ahnung hat, was es zeigt (keine Struktur), bloß, dass es auf einem Speicher der Größe "size".

    Außerhalb Ihres Aufruf von malloc, können Sie dann sagen, das Programm, das dieser Zeiger hat eine gewisse Struktur. I. e., wenn Sie eine Struktur some_struct können Sie sagen: struct some_struct *pStruct = (struct some_struct *) malloc(sizeof(struct some_struct)).

    Sehen, wie malloc kennt nur die Größe, was es wird zuweisen, aber nicht wirklich wissen, es ist Struktur? Ihr Aufruf von malloc ist übergeben keine Informationen über die Struktur, lediglich die Größe, wie viel Speicher zu reservieren.

    Dies ist C die Art und Weise des seins generic: malloc gibt Ihnen eine bestimmte Menge an Speicher, und es ist Ihre Aufgabe, um Sie zu wirken, um die strukturierten Speicher, den Sie benötigen.

    InformationsquelleAutor DWright

  4. 1
     p = (void *)malloc_ptr;

`malloc` returns a void pointer, which indicates that it is a pointer to a region of 
 unknown  data type. The use of casting is only required in C++ due to the strong type 
 system, whereas this is not the case in C. The lack of a specific pointer type 
 returned from `malloc` is `type-unsafe` behaviour according to some programmers: 
 malloc allocates based on byte count but not on type.

 malloc_ptr += size;

 `C` implicitly casts from and to `void*`, so the cast will be done automatically. In 
 `C++` only conversion to void* would be done implicitly, for the other direction an 
 explicit cast is required.

    Wiki Erklärung über Art casting,

    `malloc` function returns an untyped pointer type `void *`, which the calling code must 
 cast to the appropriate pointer type. Older C specifications required an explicit cast 
 to do so, therefore the code `(struct foo *) malloc(sizeof(struct foo))` became the 
 accepted practice. However, this practice is discouraged in ANSI C as it can mask a   
 failure to include the header file in which `malloc` is defined, resulting in 
 downstream errors on machines where the int and pointer types are of different sizes, 
 such as the now-ubiquitous x86_64 architecture. A conflict arises in code that is 
 required to compile as C++, since the cast is necessary in that language.

    InformationsquelleAutor Sunil Bojanapally

  5. 1

    Wie sehen Sie diese beiden Zeilen,

    p = (void *)malloc_ptr;
malloc_ptr += size;

    hier sind Sie mit malloc_ptr vom Typ unsigned long, so dass wir die Typumwandlung mit dieser variable void-Typ und speichern Sie es dann in p ist.
    und in gleicher Weise wie die zweite ist bezeichnet malloc_ptr = malloc_ptr + size;

    Und diese beiden codes sind für die developer ' s comfortness als p ist vom Typ void-Zeiger, so dass bei Anwendung, wenn Sie die benutzen Sie malloc-dann müssen Sie nicht wissen, welche Art von Speicher-block haben werden, durch Rückkehr-Funktion, so wird diese Funktion gibt immer diese generischen void-Zeiger ist, so sind wir in der Lage, Typumwandlung wieder in unserer Anwendung wie pro Anforderung.

    und gleich im zweiten code, wenn Sie geben Sie Größe im negativen, was dann passiert ist mit diesem Zustand 

    if (free_mem_end_ptr && malloc_ptr >= free_mem_end_ptr)
error("Out of memory");

    InformationsquelleAutor ravi bhuva

Schreibe einen Kommentar