vlambda博客
学习文章列表

//C语言内存分配

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

void main()

{

//一.动态内存分配

//内存四区：

/* 

（1）栈：     局部变量；  函数参数；

（2）堆：     由程序员 通过 malloc 动态分配free操作

（3）静态区：全局变量 ；静态变量

（4）代码段：机器指令

*/

//1.malloc 函数   ；  包含头文件#include<stdlib.h>

/*

能够在堆中动态地分配一块指定大小的内存空间。

函数原型：

void* malloc(unsigned int size);

返回：返回一个指向被分配的内存块起始位置。

失败返回NULL指针，说明没有分配成功。

*/

/*

int a = 10;

// void*  :泛形指针 ， 可以赋值给任意类型的指针

char* pchar= malloc(sizeof(char));//char型指针

//使用：

*pchar = 'A';//申请了一个空间，并且存储      ,只能存储一个字符，因为它的是一个字节。

pchar[0] = 'A';//指针可以做下标访问，与*pchar 相等，可以用此方法访问内存

pchar[1] = 'B';//越界，编译器没有把内存给它，因为char只占用一个字节，而这里是两个字节。  编译器会发生不可预知的错误。 

printf("%c\n", *pchar);

short* pshort = malloc(sizeof(short));//申请两个字节；   分配的空间是从堆里随机分配的。

*pshort = 456;

//*pshort = 456.5;//隐式类型转换

printf("%d\n", *pshort);

//只申请了一个空间，就不能存储多个字节，相当于越界。

double* pdouble = malloc(sizeof(double));

*pdouble = 456.6;

printf("%lf\n", *pdouble);

*/

//动态数组

//int arr[10];

//动态分配内存

//int n;

//printf("你的动态数组大小为：\n");

//scanf("%d", &n);

//int* parr= malloc(sizeof(int)*n);//乘以n  ;  分配了n*4个字节

////*(parr + 0) = 10;

////*(parr + 1) = 20;

//for (int i = 0; i < n;i++)

//{

//parr[i] = i*10;

//}

//for (int i = 0; i < n; i++)

//{

//printf("%d, ", parr[i]);

//}

//printf("\n");

//分配的是一段连续的内存空间

/*

char* buffer = malloc(sizeof(char)* 200);//申请一块空间 ， buffer空间就是缓冲区  ；给buffer  200个字节

//不存东西，里面就是一些垃圾，程序不会清理，需要自己去清理。

if (buffer == NULL)

{

printf("动态开辟内存失败.\n");

return 0;

}

printf("%s\n", buffer);

*/

//动态分配结构体节点

typedef struct _Node

{

int data;

struct _Node* next;

}Node;

Node* pNode=malloc(sizeof(Node));

//2. 泛型指针

/*

void*

相同类型的指针可以相互转化，泛型指针就是 ：可以转化成任何类型的指针

int *p = malloc（sizeof(int));

if(p != NULL)

{

printf("动态开辟内存成功.\n");

}

else

{

printf("动态开辟内存失败.\n");

}

*p=45;

char *p1=malloc(sizeof(char));

*p1='A';

//是分配一块连续的内存空间。

*/

//3. calloc 函数        头文件#include<stdlib.h>

/*

返回一个指向动态开拍的内存空间的指针

函数原型：

void *calloc(size_t num,size_tsize);

//分配的这块空间，会初始化为0.

//num Number of elements

size Length in bytes of each elements.

//效率 ：malloc 效率要高， calloc 还要将里面初始为0.

*/

//malloc 和calloc 的区别：

//malloc 不会将分配的内存打扫，没有赋值的不会设置为0。但calloc会全部清为0.

//malloc: 指定要分配多少个字节,一次给多少个字节。

//calloc: 首先要分配多少个，每一个多少个字节。

/*

int *parr1=calloc(10, sizeof(int));//分配10个，每个4个字节。总共40个字节

parr1[0] = 1;

parr1[1] = 2;

for (int i = 0; i < 10; i++)

{

printf("%d, ", parr1[i]);//分配的这块空间没有赋值的，会初始化为0.

}

printf("\n");

*/

//4. realloc            头文件#include<stdlib.h>

/*

用于修改原先已经分配好了的内存空间大小

函数原型：

void *realloc(void *memblock, size_t size)

memblock Pointer to previously allocated memory block.

size     New size in bytes.

//扩大

//缩小

*/

//动态数组

/*

int *parr3 = malloc(sizeof(int)*10);//40个字节

for (int i = 0; i < 10; i++)

{

parr3[i] = i + 1;

}

for (int i = 0; i < 10; i++)

{

printf("%d,", parr3[i]);

}

printf("\n");

int *parr4 = realloc(parr3, sizeof(int)* 20);//从10扩大到20

for (int i = 0; i < 20; i++)

{

printf("%d,", parr4[i]);//把malloc里面存储的东西复制到realloc中，其余扩大的部分是垃圾值

}

printf("\n");

printf("parr4=%d\n", parr4);

//释放内存：程序员手动释放(free)

free(parr4);//释放申请的parr4中的内存

*/

//5.存储释放         头文件#include<stdlib.h>

/*

free();

函数原型：

void free(void *memblock);

int *p=malloc(sizeof(int)*5);

p[0]=11;

p[1]=22;

p[2]=33;

p[3]=44;

p[4]=55;

for(int i=0;i<5;i++)

{

printf("%d\t",p[i]);

}

*/

//while(1)

//{

//int *p = malloc(sizeof(int));

//

//}

//6. 内存操作函数        头文件：#include<string.h>

/*

memcpy()

memmove()

memchr()

memset()

------------

int arr[10]={1,2,3,4,5,6,7,8,9,10};

int arr1[10];

//memcpy(arr1,arr,sizeof(arr));

memset(arr1,0,40);

for(int i=0;i<10;i++)

{

printf("%d\n",arr1[i]);

*/

//字符操作函数，只能操作字符串

/*

strcpy

strcmp

......

*/

//能够操作内存：

Node node1 = { 10, NULL }, node2;

memcpy(&node2,&node1,sizeof(Node));//内存复制函数  ，

//也可以复制字符串

char str[200];

//strcpy(str,"helloworld");

memcpy(str, "helloworld",strlen("helloworld")+1);

//memmove函数 =》复制

char str1[] = "helloworld";

//memcpy(str1, str1 + 2, 4);//从第二个 L 向后复制四个字节放在str1，将 llow 放在了 hell 的地方，相当于覆盖了hell。

//printf("%s\n", str1);

char str2[] = "helloworld";

memmove(str2, str2 + 2, 4);

printf("%s\n", str2);

//memchr函数     ;查找字符

char *pos=memchr(str1, 'e', 10);

printf("%s\n", pos);

//找不到返回NILL。

//memset 内存设置函数

char *pbuffer=malloc(sizeof(char)* 200);

memset(pbuffer, 0, sizeof(char)* 200);//全部清为0

printf("%s\n", pbuffer);

}