malloc

malloc

原型：

void * __cdecl malloc(size_t _Size);

size_t 是 unsigned int，_Size是形参，字节个数

定义：

malloc 指动态内存分配，该函数是一种分配长度为num_bytes字节的内存块的函数，可以向系统申请分配指定size个字节的内存空间。

返回值：
返回类型是 void* 类型。
如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。

使用

malloc(1);//申请一个字节空间，把这一个字节的地址返回

char * cp=(char *)malloc(sizeeof(char));//见名知意，可移植性强
char * cp=(char *)malloc(1);

short * ip=(short *)malloc(sizeeof(short));
short * ip=(short *)malloc(1);

int * zp=(int *)malloc(sizeeof(int));
int * zp=(int *)malloc(1);

注意：

void main()
{
    int *p=NULL;//定义指针必须初始化,若不初始化*p为野指针
    p =(int*)malloc(sizeof(int));
    *p=100;
    cout<<*p<<" ";
    free(p)；
    p=NULL;//必须赋值为空
}

free(p);当空间不再使用必须释放，释放实质工作就是把已用标记位1->0。p指针仍然指向这个空间首地址，这种指针为悬空指针（或失效指针：当程序运行时，由于p仍指向之前申请的空间，而系统又把该空间重新分配，使得两个指针相互侵占，带来的危害巨大，必须立即赋值为空）

malloc申请的空间存在已用标记位，当空间被占用，标记有0->1,避免再把空间分配给其他人。当free空间释放，标记为由1变为0，使得空间可以被其他人使用，提高空间利
用率

申请所需空间

void main()
{
    int nsize;
    int *p=NULL;
    cin>>nsize;
    p=(int *)malloc(sizeof(int)*nsize);

    for(int i=0;i<nsize; i++)
    {
        p[i]=i;
    }

    for(int i=0;i<nsize; i++)//nsize 必须为整数
    {
        cout<<p[i]<<" ";
    }
    cout<<endl;
    free(p);
    p=NULL;
    free(p);//空指针释放安全可以编译通过，但对本程序无意义
}

why free()既可以释放一个字节空间，也可以释放多个字节空间，怎么办到？

在malloc申请空间时，此空间有一个记录信息的“表头”，存放标记位和申请空间大小,free时向上读取“表头”信息，已达到释放任意申请多少的空间。所以malloc并不是申请多大就开辟多大，例如有一个记录控制信息的“表头”也占用一定空间。释放改变标记位，把释放空间填充为ccccccc,“表头”不填充。

与new的区别

int *p;
p = new int; //返回类型为int* 类型(整数型指针)，分配大小为 sizeof(int);
int *p1;
p1 = new int [100]; //返回类型为 int* 类型(整数型指针)，分配大小为 sizeof(int) * 100;
new 返回指定类型的指针，并且可以自动计算所需要大小。

int* p;
p = (int *) malloc (sizeof(int));
malloc 函数返回的是 void * 类型,而且必须要由我们计算字节数，并且在返回后强行转换为实际类型的指针。malloc 只管分配内存，并不能对所得的内存进行初始化，所以得到的一片新内存中，其值将是随机的。malloc函数的实参为 sizeof(int) ，用于指明一个整型数据需要的大小。在申请空间后要及时释放free()。

工作机制

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

calloc

void main()
{
    int n;
    int *p=NULL;
    cin>>n;
    p=(int*)calloc(n,sizeof(int));//开辟n个空间，并初始化为0.
          // （开辟空间个数，每个空间大小）
    for(int i=0;i<n;i++)
    {
        cout<<p[i]<<" ";
    }
    cout<<endl;
    free(p);
    p=NULL;
}

realloc

question1:

开辟10个空间并赋值为0-9，再追加10个空间，赋值10-19？
//函数化，判空

#include<iostream>
using namespace std;
#include<malloc.h>
int * Get_Int(int n)
{
    int *p = (int*)malloc(sizeof(int)*n);
    if (NULL == p)exit(1);
    return p;
}

void put_Array(int *str, int x, int y)
{
    if (str == NULL || x <= 0) return;
    for (int i = 0; i < x;i++ )
    {
        str[i] = y++;
    }
}

void my_print(int *str, int n)
{
    if (str == NULL || n <= 0) return;
    for (int i = 0; i < n; i++)
    {
        cout << str[i] << " ";
    }
    cout << endl;
}

void CopyInt(int *q, int *p, int n)
{
    if (p == NULL || q==NULL || n <= 0)return;
    for (int i = 0; i < n; i++)
    {
        q[i] = p[i];
    }
}

void main()
{
    int n,m;
    int *p = NULL;
    int *q = NULL;
    cin >> n;
    p = Get_Int(n);
    put_Array(p, n, 0);
    my_print(p, n);
    cin >> m;
    q = Get_Int(m);
    if (n >= m)
    {
        CopyInt(q, p, m);
    }
    else
    {
        CopyInt(q, p, n);
    }
    free(p);
    p = q;
    put_Array(&p[n], m - n, n);
    my_print(p, m);
    free(p);
    p = NULL;
}

功能：在原有的基础上追加空间

扩大申请的空间，在一般情况下，申请前后开辟空间的首地址不同，例如,原先申请10个空间，现在追加10个，并不知道原先申请的空间后方是否有未被申请的空间，如果该部分空间被申请，而追加的空间则会把该空间覆盖。所以一般不会追加在已经申请的空间后，而是会重新申请一个大小为追加后所需的空间，当然如果只追加了一个字节的空间则可能不会再开辟新地址下的空间。

p=(int*)realloc(p,sizeof(int)*n);