A. linux系統下的c語言中的虛擬內存分配問題
因為內存管理由glibc管理，當它認為需要釋放時，才釋放前提是，你已經讓它釋放了，說的簡單就是，你讓它釋放，它要過一段時間等合適了，再釋放
B. 怎麼用codeblocks編寫c語言的圖形程序
在codeblocks中，可以通過集成EGE庫，來實現C語言圖形程序的編寫，具體方式如下：
一、安裝：
1、下載ege安裝包；
2、將安裝包解壓；
3、把壓縮包里include目錄下所有文件，復制到編譯器安裝目錄下的include目錄內，例如D:MinGWinclude；
4、把lib目錄下對應編譯器名目錄下的文件，復制到編譯器安裝目錄下的lib目錄內,例如D:MinGWlib。
二、建立工程：
只要第1步做好以後，其實已經安裝好ege了，剩下的只是配置build option.
點擊file-new-projects，選擇Console application：
C. C語言函數的操作函數
所在函數庫為string.h、mem.h
mem…操作存貯數組
void *memccpy(void *destin,void *source,unsigned char ch,unsigned n)
void *memchr(void *s,char ch,unsigned n)
void *memcmp(void *s1,void *s2,unsigned n)
int memicmp(void *s1,void *s2,unsigned n)
void *memmove(void *destin,void *source,unsigned n)
void *memcpy(void *destin,void *source,unsigned n)
void *memset(void *s,char ch,unsigned n)
這些函數,mem…系列的所有成員均操作存貯數組.在所有這些函數中,數組是n位元組長.
memcpy從source復制一個n位元組的塊到destin.如果源塊和目標塊重疊,則選擇復制方向,
以例正確地復制覆蓋的位元組.
memmove與memcpy相同.
memset將s的所有位元組置於位元組ch中.s數組的長度由n給出.
memcmp比較正好是n位元組長的兩個字元串s1和s2.些函數按無符號字元比較位元組,因此,
memcmp(0xFF,x7F,1)返回值大於0.
memicmp比較s1和s2的前n個位元組,不管字元大寫或小寫.
memccpy從source復制位元組到destin.復制一結束就發生下列任一情況:
(1)字元ch首選復制到destin.
(2)n個位元組已復制到destin.
memchr對字元ch檢索s數組的前n個位元組.
返回值:memmove和memcpy返回destin
memset返回s的值
memcmp和memicmp─┬─若s1<s2返回值小於0
├─若s1=s2返回值等於0
└─若s1>s2返回值大於0
memccpy若復制了ch,則返回直接跟隨ch的在destin中的位元組的一個指針;
否則返回NULL
memchr返回在s中首先出現ch的一個指針;如果在s數組中不出現ch,就返回NULL.
void movedata(int segsrc,int offsrc,
int segdest,int offdest,
unsigned numbytes)
本函數將源地址(segsrc:offsrc)處的numbytes個位元組
復制到目標地址(segdest:offdest)
void movemem(void *source,void *destin,unsigned len)
本函數從source處復制一塊長len位元組的數據到destin.若源地址和目標地址字元串
重疊,則選擇復制方向,以便正確的復制數據.
void setmem(void *addr,int len,char value)
本函數把addr所指的塊的第一個位元組置於位元組value中.
str…字元串操作函數
char stpcpy(char *dest,const char *src)
將字元串src復制到dest
char strcat(char *dest,const char *src)
將字元串src添加到dest末尾
char strchr(const char *s,int c)
檢索並返回字元c在字元串s中第一次出現的位置
int strcmp(const char *s1,const char *s2)
比較字元串s1與s2的大小,並返回s1-s2
char strcpy(char *dest,const char *src)
將字元串src復制到dest
size_t strcspn(const char *s1,const char *s2)
掃描s1,返回在s1中有,在s2中也有的字元個數
char strp(const char *s)
將字元串s復制到最近建立的單元
int stricmp(const char *s1,const char *s2)
比較字元串s1和s2,並返回s1-s2
size_t strlen(const char *s)
返回字元串s的長度
char strlwr(char *s)
將字元串s中的大寫字母全部轉換成小寫字母,並返回轉換後的字元串
char strncat(char *dest,const char *src,size_t maxlen)
將字元串src中最多maxlen個字元復制到字元串dest中
int strncmp(const char *s1,const char *s2,size_t maxlen)
比較字元串s1與s2中的前maxlen個字元
char strncpy(char *dest,const char *src,size_t maxlen)
復制src中的前maxlen個字元到dest中
int strnicmp(const char *s1,const char *s2,size_t maxlen)
比較字元串s1與s2中的前maxlen個字元
char strnset(char *s,int ch,size_t n)
將字元串s的前n個字元置於ch中
char strpbrk(const char *s1,const char *s2)
掃描字元串s1,並返回在s1和s2中均有的字元個數
char strrchr(const char *s,int c)
掃描最後出現一個給定字元c的一個字元串s
char strrev(char *s)
將字元串s中的字元全部顛倒順序重新排列,並返回排列後的字元串
char strset(char *s,int ch)
將一個字元串s中的所有字元置於一個給定的字元ch
size_t strspn(const char *s1,const char *s2)
掃描字元串s1,並返回在s1和s2中均有的字元個數
char strstr(const char *s1,const char *s2)
掃描字元串s2,並返回第一次出現s1的位置
char strtok(char *s1,const char *s2)
檢索字元串s1,該字元串s1是由字元串s2中定義的定界符所分隔
char strupr(char *s)
將字元串s中的小寫字母全部轉換成大寫字母,並返回轉換後的字元串
存貯分配子程序,所在函數庫為dos.h、alloc.h、malloc.h、stdlib.h、process.h
int allocmem(unsigned size,unsigned *seg)利用DOS分配空閑的內存,
size為分配內存大小,seg為分配後的內存指針
int freemem(unsigned seg)釋放先前由allocmem分配的內存,seg為指定的內存指針
int setblock(int seg,int newsize)本函數用來修改所分配的內存長度,
seg為已分配內存的內存指針,newsize為新的長度
int brk(void *endds)
本函數用來改變分配給調用程序的數據段的空間數量,新的空間結束地址為endds
char *sbrk(int incr)
本函數用來增加分配給調用程序的數據段的空間數量,增加incr個位元組的空間
unsigned long coreleft() 本函數返回未用的存儲區的長度,以位元組為單位
void *calloc(unsigned nelem,unsigned elsize)分配nelem個長度為elsize的內存空間
並返回所分配內存的指針
void *malloc(unsigned size)分配size個位元組的內存空間,並返回所分配內存的指針
void free(void *ptr)釋放先前所分配的內存,所要釋放的內存的指針為ptr
void *realloc(void *ptr,unsigned newsize)改變已分配內存的大小,ptr為已分配有內
存區域的指針,newsize為新的長度,返回分配好的內存指針.
long farcoreleft() 本函數返回遠堆中未用的存儲區的長度,以位元組為單位
void far *farcalloc(unsigned long units,unsigned long unitsz)
從遠堆分配units個長度為unitsz的內存空間,並返回所分配內存的指針
void *farmalloc(unsigned long size)分配size個位元組的內存空間,
並返回分配的內存指針
void farfree(void far *block)釋放先前從遠堆分配的內存空間,
所要釋放的遠堆內存的指針為block
void far *farrealloc(void far *block,unsigned long newsize)改變已分配的遠堆內
存的大小,block為已分配有內存區域的指針,newzie為新的長度,返回分配好
的內存指針
D. 在windows下用C語言如何實現socket網路編程，需要用到哪些頭文件或者庫
需要用到的頭文件包含：
#include <winsock2.h>
#include <windows.h>
與Linux環境下socket編程相比，windows環境多了一個步驟：啟動或者初始化winsock庫
Winsock，一種標准API，一種網路編程介面，用於兩個或多個應用程序（或進程）之間通過網路進行數據通信。具有兩個版本：
Winsock 1:
Windows CE平台支持。
頭文件：WinSock.h
庫：wsock32.lib
Winsock 2:
部分平台如Windows CE貌似不支持。通過前綴WSA可以區別於Winsock 1版本。個別函數如WSAStartup、WSACleanup、WSARecvEx、WSAGetLastError都屬於Winsock 1.1規范的函數；
頭文件：WinSock2.h
庫：ws2_32.lib
mswsock.h用於編程擴展，使用時必須鏈接mswsock.dll
(4)sbrk的C語言實現擴展閱讀
winsock庫的載入與卸載：
載入：int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
載入成功，返回值為0。
WORD wVersionRequested：載入的winsock版本，使用宏MAKEWORD(x, y)，x表示高位元組,y表示低位元組。然而使用時MAKEWORD(2, 2)。高位元組與低位元組相同~~
LPWSADATA lpWSAData：WSADATA結構的指針，傳入參數後，系統幫助我們填充版本信息。有興趣的可以看看結構體內容，不過基本用不著。
卸載：int WSACleanup(void);比起載入，卸載的函數真是輕松愉快。
E. C語言中分配內存的函數是怎麼寫的
Windows下的 malloc 原理就是調用 windows API 的各種內存管理函數申請內存並記錄內存狀態以便將來釋放。
DOS下的 malloc 原理就是調用申請內存的中斷申請內存並記錄內存狀態以便將來釋放。
UNIX 和 Linux 都有內存管理的系統調用，malloc 相當於給這些系統調用穿了一件
malloc（）工作機制
malloc函數的實質體現在，它有一個將可用的內存塊連接為一個長長的列表的所謂空閑鏈表。調用malloc函數時，它沿連接表尋找一個大到足以滿足用戶請求所需要的內存塊。然後，將該內存塊一分為二（一塊的大小與用戶請求的大小相等，另一塊的大小就是剩下的位元組）。接下來，將分配給用戶的那塊內存傳給用戶，並將剩下的那塊（如果有的話）返回到連接表上。調用free函數時，它將用戶釋放的內存塊連接到空閑鏈上。到最後，空閑鏈會被切成很多的小內存片段，如果這時用戶申請一個大的內存片段，那麼空閑鏈上可能沒有可以滿足用戶要求的片段了。於是，malloc函數請求延時，並開始在空閑鏈上翻箱倒櫃地檢查各內存片段，對它們進行整理，將相鄰的小空閑塊合並成較大的內存塊。
malloc（）在操作系統中的實現
在 C 程序中，多次使用malloc () 和 free()。不過，您可能沒有用一些時間去思考它們在您的操作系統中是如何實現的。本節將向您展示 malloc 和 free 的一個最簡化實現的代碼，來幫助說明管理內存時都涉及到了哪些事情。
在大部分操作系統中，內存分配由以下兩個簡單的函數來處理：
void *malloc (long numbytes)：該函數負責分配 numbytes 大小的內存，並返回指向第一個位元組的指針。
void free(void *firstbyte)：如果給定一個由先前的 malloc 返回的指針，那麼該函數會將分配的空間歸還給進程的「空閑空間」。
malloc_init 將是初始化內存分配程序的函數。它要完成以下三件事：將分配程序標識為已經初始化，找到系統中最後一個有效內存地址，然後建立起指向我們管理的內存的指針。這三個變數都是全局變數：
//清單 1. 我們的簡單分配程序的全局變數
int has_initialized = 0;
void *managed_memory_start;
void *last_valid_address;
如前所述，被映射的內存的邊界（最後一個有效地址）常被稱為系統中斷點或者 當前中斷點。在很多 UNIX? 系統中，為了指出當前系統中斷點，必須使用 sbrk(0) 函數。 sbrk 根據參數中給出的位元組數移動當前系統中斷點，然後返回新的系統中斷點。使用參數 0 只是返回當前中斷點。這里是我們的 malloc 初始化代碼，它將找到當前中斷點並初始化我們的變數：
清單 2. 分配程序初始化函數
#include
void malloc_init()
{
last_valid_address = sbrk(0);
managed_memory_start = last_valid_address;
has_initialized = 1;
}
現在，為了完全地管理內存，我們需要能夠追蹤要分配和回收哪些內存。在對內存塊進行了 free 調用之後，我們需要做的是諸如將它們標記為未被使用的等事情，並且，在調用 malloc 時，我們要能夠定位未被使用的內存塊。因此， malloc 返回的每塊內存的起始處首先要有這個結構：
//清單 3. 內存控制塊結構定義
struct mem_control_block {
int is_available;
int size;
};
現在，您可能會認為當程序調用 malloc 時這會引發問題 —— 它們如何知道這個結構？答案是它們不必知道；在返回指針之前，我們會將其移動到這個結構之後，把它隱藏起來。這使得返回的指針指向沒有用於任何其他用途的內存。那樣，從調用程序的角度來看，它們所得到的全部是空閑的、開放的內存。然後，當通過 free() 將該指針傳遞回來時，我們只需要倒退幾個內存位元組就可以再次找到這個結構。
在討論分配內存之前，我們將先討論釋放，因為它更簡單。為了釋放內存，我們必須要做的惟一一件事情就是，獲得我們給出的指針，回退 sizeof(struct mem_control_block) 個位元組，並將其標記為可用的。這里是對應的代碼：
清單 4. 解除分配函數
void free(void *firstbyte) {
struct mem_control_block *mcb;
mcb = firstbyte - sizeof(struct mem_control_block);
mcb->is_available = 1;
return;
}
如您所見，在這個分配程序中，內存的釋放使用了一個非常簡單的機制，在固定時間內完成內存釋放。分配內存稍微困難一些。我們主要使用連接的指針遍歷內存來尋找開放的內存塊。這里是代碼：
//清單 6. 主分配程序
void *malloc(long numbytes) {
void *current_location;
struct mem_control_block *current_location_mcb;
void *memory_location;
if(! has_initialized) {
malloc_init();
}
numbytes = numbytes + sizeof(struct mem_control_block);
memory_location = 0;
current_location = managed_memory_start;
while(current_location != last_valid_address)
{
current_location_mcb =
(struct mem_control_block *)current_location;
if(current_location_mcb->is_available)
{
if(current_location_mcb->size >= numbytes)
{
current_location_mcb->is_available = 0;
memory_location = current_location;
break;
}
}
current_location = current_location +
current_location_mcb->size;
}
if(! memory_location)
{
sbrk(numbytes);
memory_location = last_valid_address;
last_valid_address = last_valid_address + numbytes;
current_location_mcb = memory_location;
current_location_mcb->is_available = 0;
current_location_mcb->size = numbytes;
}
memory_location = memory_location + sizeof(struct mem_control_block);
return memory_location;
}
這就是我們的內存管理器。現在，我們只需要構建它，並在程序中使用它即可.多次調用malloc（）後空閑內存被切成很多的小內存片段，這就使得用戶在申請內存使用時，由於找不到足夠大的內存空間，malloc（）需要進行內存整理，使得函數的性能越來越低。聰明的程序員通過總是分配大小為2的冪的內存塊，而最大限度地降低潛在的malloc性能喪失。也就是說，所分配的內存塊大小為4位元組、8位元組、16位元組、 18446744073709551616位元組，等等。這樣做最大限度地減少了進入空閑鏈的怪異片段（各種尺寸的小片段都有）的數量。盡管看起來這好像浪費了空間，但也容易看出浪費的空間永遠不會超過50%。
F. alloc方法和myalloc方法的區別
malloc()與 alloc()
C語言跟內存分配方式
（1） 從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。例如全局變數，static變數。
（2） 在棧上創建。在執行函數時，函數內局部變數的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置於處理器的指令集中，效率很高，但是分配的內存容量有限。
（3）從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc或new申請任意多少的內存，程序員自己負責在何時用free或delete釋放內存。動態內存的生存期由我們決定，使用非常靈活，但問題也最多
C語言跟內存申請相關的函數主要有 alloca,calloc,malloc,free,realloc,sbrk等.其中alloca是向棧申請內存,因此無需釋放. malloc分配的內存是位於堆中的,並且沒有
初始化內存的內容,因此基本上malloc之後,調用函數memset來初始化這部分的內存空間. calloc則將初始化這部分的內存,設置為0. 而realloc則對malloc申請的內存進行大小的調整.申請的內存最終需要通過函數free來釋放. 而sbrk則是增加數據段的大小;
malloc/calloc/free基本上都是C函數庫實現的,跟OS無關.C函數庫內部通過一定的結構來保存當前有多少可用內存.如果程序malloc的大小超出了庫里所留存的空間,那麼
將首先調用brk系統調用來增加可用空間,然後再分配空間.free時,釋放的內存並不立即返回給os,而是保留在內部結構中. 可以打個比方: brk類似於批發,一次性的向OS申請大的內存,而malloc等函數則類似於零售,滿足程序運行時的要求.這套機制類似於緩沖.使用這套機制的原因: 系統調用不能支持任意大小的內存分配(有的系統調用只支持固定大小以及其倍數的內存申請,這樣的話,對於小內存的分配會造成浪費; 系統調用申請內存代價昂貴,涉及到用戶態和核心態的轉換.
函數malloc()和calloc()都可以用來分配動態內存空間，但兩者稍有區別。
malloc()函數有一個參數，即要分配的內存空間的大小：
Void *malloc(size_t size);
calloc()函數有兩個參數，分別為元素的數目和每個元素的大小，這兩個參數的乘積就是要分配的內存空間的大小：
void *calloc(size_t numElements，size_t sizeOfElement)；
如果調用成功，函數malloc()和calloc()都將返回所分配的內存空間的首地址。
malloc() 函數和calloc ()函數的主要區別是前者不能初始化所分配的內存空間，而後者能。如果由malloc()函數分配的內存空間原來沒有被使用過，則其中的每一位可能都是 0；反之，如果這部分內存空間曾經被分配、釋放和重新分配，則其中可能遺留各種各樣的數據。也就是說，使用malloc()函數的程序開始時(內存空間還 沒有被重新分配)能正常運行，但經過一段時間後(內存空間已被重新分配)可能會出現問題。
calloc() 函數會將所分配的內存空間中的每一位都初始化為零，也就是說，如果你是為字元類型或整數類型的元素分配內存，那麼這些元素將保證會被初始化為零；如果你是為指針類型的元素分配內存，那麼這些元素通常(但無法保證)會被初始化為空指針；如果你是為實數類型的元素分配內存，那麼這些元素可能(只在某些計算機中)會被初始化為浮點型的零。
malloc() 函數和calloc ()函數的另一點區別是calloc()函數會返回一個由某種對象組成的數組，但malloc()函數只返回一個對象。為了明確是為一個數組分配內存空 間，有些程序員會選用calloc()函數。但是，除了是否初始化所分配的內存空間這一點之外，絕大多數程序員認 為以下兩種函數調用方式沒有區別：
calloc(numElements ，sizeOfElement)；
malloc(numElements *sizeOfElement) ；
需要解釋的一點是，理論上(按 照ANSIC標准)指針的算術運算只能在一個指定的數組中進行，但是在實踐中，即使C編譯程序或翻譯器遵循這種規定，許多C程序還是沖破了這種限制。因 此，盡管malloc()函數並不能返回一個數組，它所分配的內存空間仍然能供一個數組使用(對realloc()函數來說同樣如此，盡管它也不能返回一 個數組)。
總之，當你在calloc()函數和malloc()函數之間作選擇時，你只需考慮是否要初始化所分配的內存空間，而不用考慮函數是否能返回一個數組。
當程序運行過程中malloc了,但是沒有free的話,會造成內存泄漏.一部分的內存沒有被使用,但是由於沒有free,因此系統認為這部分內存還在使用,造成不斷的向系統申請內存,是的系統可用內存不斷減少.但是,內存泄漏僅僅指程序在運行時,程序退出時,OS將回收所有的資源.因此,適當的重起一下程序,有時候還是有點作用.
G. c語言中的brk和sbrk的區別是什麼
一個是標C的 一個是unix 的 brk函數的參數 是 指針 sbrk的參數是 int類型的
H. 請用C語言編寫 malloc realloc free 函數。
//IBM的實現，僅供參考
/* Include the sbrk function */
#include <unistd.h>
int has_initialized = 0;
void *managed_memory_start;
void *last_valid_address;
void malloc_init()
{
/* grab the last valid address from the OS */
last_valid_address = sbrk(0);
/* we don't have any memory to manage yet, so
*just set the beginning to be last_valid_address
*/
managed_memory_start = last_valid_address;
/* Okay, we're initialized and ready to go */
has_initialized = 1;
}
struct mem_control_block {
int is_available;
int size;
};
void free(void *firstbyte) {
struct mem_control_block *mcb;
/* Backup from the given pointer to find the
* mem_control_block
*/
mcb = firstbyte - sizeof(struct mem_control_block);
/* Mark the block as being available */
mcb->is_available = 1;
/* That's It! We're done. */
return;
}
void *malloc(long numbytes) {
/* Holds where we are looking in memory */
void *current_location;
/* This is the same as current_location, but cast to a
* memory_control_block
*/
struct mem_control_block *current_location_mcb;
/* This is the memory location we will return. It will
* be set to 0 until we find something suitable
*/
void *memory_location;
/* Initialize if we haven't already done so */
if(! has_initialized) {
malloc_init();
}
/* The memory we search for has to include the memory
* control block, but the user of malloc doesn't need
* to know this, so we'll just add it in for them.
*/
numbytes = numbytes + sizeof(struct mem_control_block);
/* Set memory_location to 0 until we find a suitable
* location
*/
memory_location = 0;
/* Begin searching at the start of managed memory */
current_location = managed_memory_start;
/* Keep going until we have searched all allocated space */
while(current_location != last_valid_address)
{
/* current_location and current_location_mcb point
* to the same address. However, current_location_mcb
* is of the correct type so we can use it as a struct.
* current_location is a void pointer so we can use it
* to calculate addresses.
*/
current_location_mcb =
(struct mem_control_block *)current_location;
if(current_location_mcb->is_available)
{
if(current_location_mcb->size >= numbytes)
{
/* Woohoo! We've found an open,
* appropriately-size location.
*/
/* It is no longer available */
current_location_mcb->is_available = 0;
/* We own it */
memory_location = current_location;
/* Leave the loop */
break;
}
}
/* If we made it here, it's because the Current memory
* block not suitable, move to the next one
*/
current_location = current_location +
current_location_mcb->size;
}
/* If we still don't have a valid location, we'll
* have to ask the operating system for more memory
*/
if(! memory_location)
{
/* Move the program break numbytes further */
sbrk(numbytes);
/* The new memory will be where the last valid
* address left off
*/
memory_location = last_valid_address;
/* We'll move the last valid address forward
* numbytes
*/
last_valid_address = last_valid_address + numbytes;
/* We need to initialize the mem_control_block */
current_location_mcb = memory_location;
current_location_mcb->is_available = 0;
current_location_mcb->size = numbytes;
}
/* Now, no matter what (well, except for error conditions),
* memory_location has the address of the memory, including
* the mem_control_block
*/
/* Move the pointer past the mem_control_block */
memory_location = memory_location + sizeof(struct mem_control_block);
/* Return the pointer */
return memory_location;
}
I. brk函數的具體功能，還有內存的分配
這是留學生c語言的一個知識點。c語言的malloc函數就是調用系統調用brk/sbrk來進行動態內存分配的。brk的參數時調整後的地址，sbrk的參數是希望調整的數量。在調用這2個系統調用時，要注意系統內存分配一般是按頁為最小單位，而不是按位元組為最小單位的。這個可以自己做測試就知道。
C語言是一門面向過程的、抽象化的通用程序設計語言，廣泛應用於底層開發。C語言能以簡易的方式編譯、處
理低級存儲器。C語言是僅產生少量的機器語言以及不需要任何運行環境支持便能運行的高效率程序設計語言。
關於C語言程序設計
過程語言-C程序中的指令是一步一步執行的。
便攜的-您可以將C程序從一個平台移動到另一個平台，並在沒有任何或最小更改的情況下運行它。
速度- C編程比Java、Python等大多數編程語言都要快。
通用的- C編程可以用來開發操作系統、嵌入式系統、資料庫等等。
J. brk()函數與sbrk（）函數怎樣動態分配空間
brk和sbrk主要的工作是實現虛擬內存到內存的映射.在GNUC中,內存分配是這樣的:
每個進程可訪問的虛擬內存空間為3G，但在程序編譯時，不可能也沒必要為程序分配這么大的空間，只分配並不大的數據段空間，程序中動態分配的空間就是從這 一塊分配的。如果這塊空間不夠，malloc函數族（realloc，calloc等）就調用sbrk函數將數據段的下界移動，sbrk函數在內核的管理 下將虛擬地址空間映射到內存，供malloc函數使用。
sbrk不是系統調用，是C庫函數。系統調用通常提供一種最小功能，而庫函數通常提供比較復雜的功能。
C語言跟內存申請相關的函數主要有 alloc,calloc,malloc,free,realloc,sbrk等.其中alloc是向棧申請內存,因此無需釋放. malloc分配的內存是位於堆中的,並且沒有初始化內存的內容,因此基本上malloc之後,調用函數memset來初始化這部分的內存空 間.calloc則將初始化這部分的內存,設置為0. 而realloc則對malloc申請的內存進行大小的調整.申請的內存最終需要通過函數free來釋放. 而sbrk則是增加數據段的大小;
malloc/calloc/free基本上都是C函數庫實現的,跟OS無關.C函數庫內部通過一定的結構來保存當前有多少可用內存.如果程序 malloc的大小超出了庫里所留存的空間,那麼將首先調用brk系統調用來增加可用空間,然後再分配空間.free時,釋放的內存並不立即返回給os, 而是保留在內部結構中. 可以打個比方: brk類似於批發,一次性的向OS申請大的內存,而malloc等函數則類似於零售,滿足程序運行時的要求.這套機制類似於緩沖.