Verwendung der Malloc-Funktion

Der vollständige Name von malloc ist Speicherzuweisung, die auf Chinesisch als dynamische Speicherzuweisung bezeichnet wird. Sie wird verwendet, um einen kontinuierlichen Speicherblockbereich einer bestimmten Größe zu beantragen und zurückzugeben Zugeordnete Speicherbereichsadresse im Typ void* Wenn dies nicht möglich ist. Wenn Sie den spezifischen Speicherort kennen und den tatsächlichen Speicherplatz binden möchten, müssen Sie Speicher dynamisch zuweisen. Der Typ

void* stellt einen untypisierten Zeiger dar. C und C++ schreiben vor, dass der Typ void* durch Typkonvertierung in einen Zeiger eines beliebigen anderen Typs umgewandelt werden kann.

Muss im Allgemeinen mit der kostenlosen Funktion gekoppelt werden.

Funktionsdefinition

Prototyp

extern void *malloc(unsigned int num_bytes);

Header-Datei

#include <stdlib.h>

Funktionsdeklaration

void *malloc(size_t size);

Bemerkungen: void* Stellt einen Zeiger eines unbestimmten Typs dar. void * kann auf jede Art von Daten verweisen. Genauer gesagt bedeutet dies, dass bei der Beantragung von Speicherplatz nicht bekannt ist, welche Art von Daten der Benutzer zum Speichern verwenden wird als char oder int oder anderer Datentyp).

Rückgabewert

Wenn die Zuweisung erfolgreich ist, wird der Zeiger auf den zugewiesenen Speicher zurückgegeben (der Anfangswert in diesem Speicherbereich ist unsicher), andernfalls wird der Nullzeiger NULL zurückgegeben. Wenn der Speicher nicht mehr verwendet wird, sollte die Funktion free() verwendet werden, um den Speicherblock freizugeben. Der von der Funktion zurückgegebene Zeiger muss richtig ausgerichtet sein, damit er mit jedem Datenobjekt verwendet werden kann.

Erklärung

In Bezug auf den Prototyp dieser Funktion hat malloc zuvor einen char-Zeiger zurückgegeben. Der neue ANSIC-Standard schreibt vor, dass diese Funktion einen void-Zeiger zurückgibt, sodass bei Bedarf eine Typkonvertierung erforderlich ist. Es kann für das System gelten, einen Speicherblock mit einer Länge von num_bytes (oder size) Bytes zuzuweisen.

Im Allgemeinen muss es mit der kostenlosen Funktion gekoppelt werden. Die Free-Funktion kann eine dynamisch zugewiesene Adresse freigeben, um anzuzeigen, dass dieser dynamisch zugewiesene Speicher nicht mehr verwendet wird, und den zuvor dynamisch zugewiesenen Speicher an das System zurückgeben.

Verwandte Funktionen

calloc, realloc, free, _alloca.

Der Unterschied zwischen new Wenn stdlib.h für eine darin implementierte Funktion nicht direkt oder indirekt im Quellcode enthalten ist, meldet gcc einen Fehler: „malloc“ wurde darin nicht deklariert Umfang. Wenn die Zieldatei generiert wird (unter der Annahme, dass malloc dynamisch verknüpft ist), wenn auf der laufenden Plattform keine libc vorhanden ist (geben Sie für die Linux-Plattform einfach LD_LIBRARY_PATH manuell in ein leeres Verzeichnis ein) oder wenn in libc keine malloc-Funktion vorhanden ist, dann wird dies der Fall sein zur Laufzeit ausgeführt (Laufzeit) Etwas ist schief gelaufen. New ist nicht der Fall. Es ist ein Schlüsselwort in C++ und keine Funktion selbst. new hängt nicht von der Header-Datei ab. Der C++-Compiler kann new in den Zielcode kompilieren (g++4.6.3 fügt die _Znwm-Funktion in das Ziel ein. Darüber hinaus fügt der Compiler auch die entsprechende Struktur entsprechend dem Typ ein des Parameters).

In Bezug auf die Verwendung weisen malloc und new mindestens zwei Unterschiede auf: new gibt einen Zeiger des angegebenen Typs zurück und kann die erforderliche Größe automatisch berechnen. Zum Beispiel:

int *p;
p = new int;
//返回类型为int *类型(整数型指针)，分配大小为sizeof(int);

oder:

int *parr;
parr = new int[100];
//返回类型为int *类型(整数型指针)，分配大小为sizeof(int) * 100;

und malloc erfordert, dass wir die Anzahl der Bytes berechnen und nach der Rückgabe die Konvertierung in einen Zeiger des tatsächlichen Typs erzwingen.

int *p;
p = (int*)malloc(sizeof(int) * 128);
//分配128个（可根据实际需要替换该数值）整型存储单元，
//并将这128个连续的整型存储单元的首地址存储到指针变量p中
double *pd = (double*)malloc(sizeof(double) * 12);
//分配12个double型存储单元，
//并将首地址存储到指针变量pd中

Zunächst gibt die malloc-Funktion den Typ void * zurück.

Wenn Sie für C++ Folgendes schreiben: p = malloc (sizeof(int)); dann kann das Programm nicht kompiliert werden und es wird eine Fehlermeldung angezeigt: „void* kann keiner Variablen vom Typ int * zugewiesen werden“ .

Sie müssen also (int *) übergeben, um zu wirken. Für C gibt es keine solche Anforderung, aber um die Transplantation von C-Programmen nach C++ zu erleichtern, wird empfohlen, die erzwungene Konvertierung zur Gewohnheit zu machen.

Zweitens ist der eigentliche Parameter der Funktion sizeof(int), der verwendet wird, um die erforderliche Größe ganzzahliger Daten anzugeben.

Sie müssen auf einen Sonderfall von malloc(0) achten. Der Rückgabewert kann NULL oder eine gültige Adresse sein (er kann sicher freigegeben, aber nicht dereferenziert werden). Beachten Sie, dass malloc(-1) nicht verboten ist. Wenn es sich um eine negative Zahl handelt, wird sie normalerweise in eine sehr große positive Zahl umgewandelt genügend Speicherblock.

In Standardprogrammen müssen wir malloc und free in diesem Format verwenden:

type *p;
if(NULL == (p = (type*)malloc(sizeof(type))))
/*请使用if来判断,这是有必要的*/
{
    perror("error...");
    exit(1);
}
.../*其它代码*/
free(p);
p = NULL;/*请加上这句*/

malloc kann auch den Effekt von new [] erzielen und für einen kontinuierlichen Speicher gelten als Es gibt die Speichergröße an, die Sie benötigen.

Wenn Sie beispielsweise 100 int-Typ-Leerzeichen zuweisen möchten:

int *p = (int*)malloc(sizeof(int) * 100);
//分配可以放得下100个整数的内存空间。

Ein weiterer Unterschied, der nicht direkt gesehen werden kann, besteht darin, dass malloc nur Speicher zuweist und den resultierenden Speicher nicht initialisieren kann, sodass wir einsteigen Ein neues Stück Speicher, dessen Wert zufällig ist.

Mit Ausnahme der unterschiedlichen Zuordnungs- und endgültigen Freigabemethoden wird der Zeiger über malloc oder new abgerufen, und andere Vorgänge sind konsistent.

Fügen Sie einen Sonderfall hinzu

char *ptr;
if((ptr = (char*)malloc(0)) == NULL)
    puts("Gotanullpointer");
else
    puts("Gotavalidpointer");

Zu diesem Zeitpunkt erhalten Sie möglicherweise „Got a valid pointer“ oder „Got a null pointer“.

Arbeitsmechanismus

malloc函数的实质体现在，它有一个将可用的内存块连接为一个长长的列表的所谓空闲链表。调用malloc函数时，它沿连接表寻找一个大到足以满足用户请求所需要的内存块。然后，将该内存块一分为二（一块的大小与用户请求的大小相等，另一块的大小就是剩下的字节）。接下来，将分配给用户的那块内存传给用户，并将剩下的那块（如果有的话）返回到连接表上。调用free函数时，它将用户释放的内存块连接到空闲链上。到最后，空闲链会被切成很多的小内存片段，如果这时用户申请一个大的内存片段，那么空闲链上可能没有可以满足用户要求的片段了。于是，malloc函数请求延时，并开始在空闲链上翻箱倒柜地检查各内存片段，对它们进行整理，将相邻的小空闲块合并成较大的内存块。如果无法获得符合要求的内存块，malloc函数会返回NULL指针，因此在调用malloc动态申请内存块时，一定要进行返回值的判断。

Linux Libc6采用的机制是在free的时候试图整合相邻的碎片，使其合并成为一个较大的free空间。

程序示例

正常程序

typedef struct data_type{
    int age;
    char name[20];
}data;
data*bob=NULL;
bob=(data*)malloc(sizeof(data));
if(bob!=NULL)
{
    bob->age=22;
    strcpy(bob->name,"Robert"); 
    printf("%s is %d years old.\n",bob->name,bob->age);
}
else
{
    printf("mallocerror!\n");
    exit(-1);
}  
free(bob);
bob=NULL;

输出结果：Robert is 22 years old.

内存泄漏实例

#include <stdio.h>
#include <malloc.h>
#define MAX 100000000int main(void)

{
    int *a[MAX] = {NULL};
    int i;
    for(i=0;i<MAX;i++)
    {
    a[i]=(int*)malloc(MAX);
    }
    return 0;
}

注：malloc申请之后没有检测返回值。

推荐教程：C#视频教程

Das obige ist der detaillierte Inhalt vonVerwendung der Malloc-Funktion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!