二十一、动态内存管理

最新推荐文章于 2024-11-02 15:22:06 发布
最新推荐文章于 2024-11-02 15:22:06 发布
阅读量361 收藏 30
点赞数 51
分类专栏： C语言笔记 文章标签： c语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HackerKevon/article/details/133808248
版权

1 动态内存开辟

目前为止，我们已经掌握的内存开辟方式有：

int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

上述开辟空间的方式其实有两个缺点：

  1. 空间开辟的大小是固定的，一旦开辟就不能再修改。
  2. 数组在声明的时候，必须指定数组的长度，所需要的内存在编译时就分配了。

而在实际情况中，有时候我们需要的空间大小在程序运行的时候才能知道， 那么数组在编译时开辟空间的方式就不能满足了。

要解决这个问题，就需要使用动态内存函数，这些函数全部包含在头文件<stdlib.h>中。

2 动态内存函数

2.1 malloc

在C语言中，提供了动态内存开辟的函数：

void* malloc (size_t size);

这个函数能够向内存申请一块连续可用的空间，并返回指向这块空间的指针。

关于malloc函数，需要注意以下几点：

  1. 如果开辟成功，则返回一个指向开辟好空间的指针。

  2. 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

  3. 返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候需要使用者自己来决定。

  4. 如果参数size为0，即开辟0个字节，malloc的行为是标准未定义的，取决于编译器。

  5. malloc申请到空间后会直接返回这块空间的起始地址，不会初始化空间的内容。

  6. 和局部变量、形式参数等存放在内存的栈区不同，动态内存开辟的空间存放在内存的堆区。

例：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)//如果p为空，则开辟空间失败
	{
		perror("malloc");
		return 1;
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%p\n", p + i);//打印所开辟空间的值
	}
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

由于malloc申请到空间后会直接返回这块空间的起始地址，不会初始化空间的内容，所以我们从输出结果可以看到我们打印所开辟空间的值是一串乱码。

2.2 free

由于malloc申请的空间只有在程序退出时才会还给操作系统，并不会主动释放，所以C语言提供了另外一个函数free，专门用来释放和回收动态内存，其原型如下：

void free (void* ptr);

关于free函数，需要注意以下几点：

  1. 如果参数ptr指向的空间不是动态开辟的，那么free函数的行为未定义。
  2. 如果参数ptr是NULL指针，则free函数什么事都不做。
  3. 用free释放完参数ptr指向的空间后，一定要把ptr置为NULL，否则ptr就是野指针。

例：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int num = 0;
	int i = 0;
	scanf("%d", &num);//输入空间的大小
	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (NULL != ptr)//判断ptr指针是否为空
	{
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}
	}
	for (i = 0; i < num; i++)
	{
		printf("%d ", *(ptr + i));
	}
	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.3 calloc

C语言还提供了一个calloc函数也可以用来动态内存分配，其原型如下：

void* calloc (size_t num, size_t size);

calloc函数可以为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0，这里和malloc不会初始化空间的内容有所不同。

例：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int i = 0;
	int* p = (int*)calloc(10, sizeof(int));
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	printf("\n");
	if (NULL != p)
	{
		for (i = 0; i < 10; i++)
		{
			*(p + i) = 1;
		}
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.4 realloc

有时候我们会发现过去申请的空间太小了，而有时候又会觉得申请的空间过大了，那么为了合理的分配内存，C语言中还提供了一个realloc函数来实现对动态开辟的内存大小进行调整，其原型如下：

void* realloc (void* ptr, size_t size);

关于realloc函数，需要注意以下几点：

  1. 参数ptr表示要调整的内存地址。
  2. 参数size表示调整之后的内存大小。
  3. 函数的返回值为调整之后的内存起始地址。
  4. 如果参数ptr为空指针，那么realloc的功能和malloc相同。

需要特别说明的是，realloc函数在调整内存空间时存在两种情况：

情况一：原有空间的后面还有足够大的空间。

在这种情况下， 要扩展内存就可以直接在原有内存之后追加空间，原来空间的数据不发生变化。

情况二：原有空间的后面没有足够大的空间。

在这种情况下，realloc函数需要先在堆空间上另找一个合适大小的连续空间来使用，然后将旧空间中的数据拷贝到新空间，拷贝完成之后会释放掉旧空间，最后返回新空间的起始地址。

情况三：找不到足够大的空间扩容。

在这种情况下，realloc函数就会返回一个空指针。如果扩容失败，由于之前的空间没有释放，而此时ptr已被置空，这就导致我们丢失了原来那个空间的地址，进而让我们无法对这片空间进行释放，像这种无法释放已申请的内存空间的情况就被称为内存泄漏。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

为了避免情况三的出现，我们使用realloc来扩容的时候应该创建一个新的指针变量来指向扩容后的空间，如果扩容失败，那么这个指针为空也不会影响我们找到原来的空间，如果扩容成功，我们就可以把指向原来空间的指针改为指向扩容后的空间。

例：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	printf("\n");
	//增加空间
	int* ptr = realloc(p, 80);
	if (ptr != NULL)//判断扩容是否成功
	{
		p = ptr;
		ptr = NULL;
	}
	else
	{
		perror("realloc");//扩容失败，报错
		return 1;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3 内存泄漏

3.1 内存泄漏的概念

内存泄漏指的是因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。

需要指出的是，内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，从而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

3.2 内存泄漏的分类

在C/C++程序中，一般我们只关心两方面的内存泄漏：

  1. 堆内存泄漏（Heap leak)

当我们通过malloc、calloc、realloc 、new等从堆中分配出一块内存，假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生堆内存泄漏。

  1. 系统资源泄漏

当程序使用系统分配的资源，比如套接字、文件描述符、管道等没有使用对应的函数释放掉，就会产生系统资源泄漏。系统资源泄漏在严重时可导致系统效能减少，系统执行不稳定。

4 常见的动态内存错误

4.1 对NULL指针进行解引用

void test()
{
 	int *p = (int *)malloc(INT_MAX/4);
 	*p = 20;//如果p的值是NULL，就会有问题
 	free(p);
}

4.2 对动态开辟的空间越界访问

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));//开辟40个字节即10个整型的空间
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//当i是10的时候越界访问
	}
	free(p);
}

4.3 对非动态开辟的空间使用free释放

void test()
{
	int a = 10;
	int* p = &a;
	free(p);//无法释放
}

4.4 使用free释放动态开辟空间的一部分

void test()
{
	int* p = (int*)malloc(100);
	p++;//p不再指向动态内存的起始位置
	free(p);
}

4.5 对同一块动态内存多次释放

void test5()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);//重复释放
}
//为了避免这种情况，可以在释放完之后就将p置空，这样哪怕重复释放free函数也不会做任何操作

4.6 动态开辟内存忘记释放（内存泄漏）

void test6()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
}
int main()
{
    test6();
    //除了函数之后，局部指针变量p被销毁，找不到原来开辟的空间，造成内存泄漏
}

5 动态内存经典面试题

5.1 题目一

//请问运行Test函数会有什么样的结果？
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

从输出结果可以看到，代码运行起来后崩溃了。

通过解读代码不难发现，代码的本意是想通过GetMemory函数给str指向的地址开辟内存空间，要实现这个功能应该将str的地址传给GetMemory也就是传址调用。但是由于GetMemory的参数类型和实参str一样同为char*类型，导致在这个地方实际进行的传值调用，也就是只把str中的NULL传给了p。虽然GetMemory中为p开辟了一块内存空间，但是p是局部变量出了作用域就被销毁了，而且由于p被销毁，我们将丢失那块内存空间的地址，也就是说还造成了内存泄漏。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

从调试结果可以看到，当我们想把字符串"hello world"拷贝到str指向的空间时，由于str是一个空指针所以导致程序崩溃。

5.2 题目二

//请问运行Test函数会有什么样的结果？
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

int main()
{
	Test();
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

其实这道题目和上面那道题有相似之处。这道题中，str想通过GetMemory函数得到指向字符串"hello world"的指针p，但是由于p是一个局部变量出了GetMemory函数即被销毁，所以当str得到p中存放的地址时p中的内容已被销毁，也就是说此时str拿到的是一个野指针，对野指针进行访问得到的自然就是一串乱码了。

5.3 题目三

//请问运行Test函数会有什么样的结果？
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}

int main()
{
	Test();
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这道题和题目一相比，虽然能够打印出字符串，但是致命的一点是没有内存释放。正确的写法应该是将str所指向的空间用free释放后，再将str置空。

5.4 题目四

//请问运行Test函数会有什么样的结果？
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

int main()
{
	Test();
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这道题目虽然输出了字符串，但是str所指向的空间被释放后还对str所指向的空间进行利用是不合适的，正确的做法应该是在释放掉str所指向的空间后就将str置空。

6 C/C++程序的内存开辟

之前我们简单了解过C/C++程序中内存区域的划分，现在了解了动态内存后我们又可以对内存区域的划分有更深入的了解。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

从上图中，可以看到C/C++程序内存分配的区域有：

  1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，虽然效率很高，但是分配的内存容量有限，所以栈区主要存放运行函数时分配的局部变量、函数参数、返回数据、返回地址等。
  2. 堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由系统回收 。分配方式类似于链表。
  3. 数据段（静态区）（static）：用于存放全局变量、静态数据，程序结束后由系统释放。
  4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

7 柔性数组

在C99中，结构体中最后一个元素允许是未知大小的数组，就叫做柔性数组成员。

例：

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;

如果有些编译器报错，那么可以写成：

typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;

7.1 柔性数组的特点

  1. 结构中的柔性数组成员前面必须至少有一个其他成员。
  2. 如果用sizeof计算含有柔性数组成员的结构体的大小，那么计算的大小将不包括柔性数组的内存。
  3. 包含柔性数组成员的结构体用malloc函数进行内存的动态分配，并且分配的内存大于结构体的大小，以适应柔性数组的预期大小。

例：

#include <stdio.h>
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

7.2 柔性数组的使用

例：

#include <stdio.h>
typedef struct st_type
{
	int i;
	int arr[0];//柔性数组成员
}type_a;
int main()
{
	printf("%d\n", sizeof(type_a));
	type_a* S1 = (type_a*)malloc(sizeof(type_a) + 40);//40是分配给柔性数组的内存
	if (S1 == NULL)
	{
		perror("malloc");
		return 1;
	}
	printf("%d\n", sizeof(type_a));
	for (int i = 0; i < 10; i++)
	{
		S1->arr[i] = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", S1->arr[i]);
	}
	printf("\n");
	//扩容
	type_a* S2 = (type_a*)realloc(S1, sizeof(type_a) + 60);
	if (S2 == NULL)
	{
		perror("realloc");
		return 1;
	}
	S1 = S2;
	for (int i = 10; i < 15; i++)
	{
		S1->arr[i] = i;
	}
	for (int i = 0; i < 15; i++)
	{
		printf("%d ", S1->arr[i]);
	}
	free(S1);
	S1 = NULL;
	S2 = NULL;
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

上面的代码展示了给柔性数组开辟空间以及扩容的过程。从输出结果可以看到，虽然我们已经给柔性数组arr开辟了内存，但是在用sizeof计算出的结构体大小仍为4。

7.3 柔性数组的优点

其实刚才我们设计的type_a的结构，也可以通过下面的方式来实现：

#include <stdio.h>
typedef struct S
{
	int n;
	int* arr;
}type_a;
int main()
{
	type_a* ps = (type_a*)malloc(sizeof(type_a));
	if (ps == NULL)
	{
		perror("malloc->ps");
		return 1;
	}
	ps->arr = (int*)malloc(40);
	if (ps->arr == NULL)
	{
		perror("malloc->ps->arr");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
	//扩容
	int* ptr = (int*)realloc(ps->arr, 60);
	if (ptr == NULL)
	{
		perror("realloc->ps->arr");
		return 1;
	}
	ps->arr = ptr;
	for (i = 10; i < 15; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 15; i++)
	{
		printf("%d ", ps->arr[i]);
	}
    free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

但是用柔性数组实现，具有几个好处：

  1. 方便内存释放
    如果我们的代码需要嵌套在别人用的函数中，当我们在里面做了二次内存分配，并把整个结构体返回给用户。虽然用户可以调用free来释放结构体，但是用户并不知道这个结构体内的成员也需要free，而我们不能指望用户来发现这件事。所以，通过柔性数组我们就可以把结构体的内存以及其成员所需的内存一次性分配完成，并返回给用户一个结构体指针，这样用户只需使用一次free就可以把所有的内存都释放掉。

  2. 利于提升访问速度
    连续的内存有益于提高访问速度，也有益于减少内存碎片。

HackerKevn
关注
专栏目录
Linux内存管理（二十一）：buddy 系统简介和初始化
私房菜
07-22 1349
在zone初始化一文中简单剖析了zone的初始化流程，也是继memblock初始化和SPARSEMEM初始化之后有一个内存管理层，而zone这一层管理层中，所有的物理内存都会被添加到zone中的成员变量free_area数组管理，而它就是buddy系统管理的核心数据结构。本文将该数据结构单独拉出来进行分析，并通过其剖析buddy系统的管理原理。.........................................................
FreeRTOS操作系统——内存管理（二十一）
戚晨夕的博客
02-05 1869
FreeRTOS操作系统学习 文章目录FreeRTOS操作系统学习前言一、内存管理简介二、内存管理1、内存碎片简介2、内存分配方法1.heap_1.c2.heap_2.c3.heap_3.c4.heap_4.c5.heap_5.c三、内存管理实验总结 前言 内存管理是一个系统基本组成部分，FreeRTOS 中大量使用到了内存管理，比如创建任务、信号量、队列等会自动从堆中申请内存。用户应用层代码也可以 FreeRTOS 提供的内存管理函数来申请和释放内存 一、内存管理简介 FreeRTOS 创建任务、队列、信
高端内存映射之kmap_atomic固定映射--Linux内存管理(二十一)
OSKernelLAB(gatieme)
09-29 5870
日期 内核版本 架构 作者 GitHub CSDN 2016-09-29 Linux-4.7 X86 & arm gatieme LinuxDeviceDrivers Linux内存管理 在内核初始化完成之后, 内存管理的责任就由伙伴系统来承担. 伙伴系统基于一种相对简单然而令人吃惊的强大算法.Linux内核使用二进制伙伴算法来管理和分配物理内存页面, 该算
自用学习资料，Linux内核之【内存管理】的一些分享
a410974689的博客
12-23 1065
本文涉及的资料全部打包放到我Github仓： GitHub - 0voice/kernel_memory_management: 总结整理linux内核的内存管理的资料，包含论文，文章，视频，以及应用程序的内存泄露，内存池相关 有需要的可以前去下载，或者觉得还不错，请给我Star，感谢支持！ ???? 100篇文章 内存管理（一）：硬件原理 和 分页管理 内存管理（二）：内存的动态申请和释放 内存管理（三）：进程的内存消耗和泄漏 内存管理（四）：内存与IO的交换 内存管理（五）：其他工程问题以及调优 -
二十一、FreeRTOS之FreeRTOS内存管理
王同学
12-11 1054
在使用FreeRTOS创建任务、队列、信号量等对象的时候，一般都提供了两种方法： 动态方法创建：自动的从FreeRTOS管理的内存堆中申请创建对象所需的内存，并在对象删除后，可将这块内存释放回FreeRTOS管理的内存堆 静态方法创建：需要用户提供各种内存空间，并且使用静态方式占用的内存一般固定下来了，即使任务、队列被删除后，这些被占用的内存空间一般没有其他途径。 总结：动态方式管理内存相比静态方式更加灵活。 除了FreeRTOS提供的动态内存管理方法，标准的C库也提供了malloc()函数和fre
DPDK 大页内存原理（二十一）
bob的博客
05-31 1546
在分析dpdk大页内存的源码之前，有必要对linux内存管理的原理以及大页内存的原理有个了解，缺少这些底层基础知识，分析dpdk大页内存的源码将举步维艰。这篇文章详细介绍下linux内存管理以及大页内存的方方面面，为分析dpdk大页内存源码扫除障碍。 一、linux内存管理原理 1、mmu内存管理的引入 在没有引入mmu内存管理单元时，对于32位操作系统，每个进程都有2的32次方的地址空间(4G)。如果进程A占用内存0x1000—0x2000物理地址空间， 而进程B也占用内存0x1000—0x2000物理地
动态配置定时任务mysql github_spring-boot-route（二十一）quartz实现动态定时任务
weixin_40008566的博客
02-04 197
Quartz是一个定时任务的调度框架，涉及到的主要概念有以下几个：Scheduler：调度器，所有的调度都由它控制，所有的任务都由它管理。Job：任务，定义业务逻辑。JobDetail：基于Job，进一步封装。其中关联一个Job，并为Job指定更详细的信息。Trigger：触发器，可以指定给某个任务，指定任务的触发机制。一 创建简单任务1.1 Quartz依赖org.springframework...
RT_Thread应用18—内存管理2
噗噗bug博客
12-27 429
第二十四章 内存管理（第二部分） 六、静态内存管理的函数接口 静态内存管理函数的使用——开发流程： 规划一片内存区域作为静态内存池。 调用 rt_mp_create()函数。进行静态内存使用前的创建。 调用 rt_mp_alloc()函数。系统内部将会从空闲链表中获取第一个空闲块，并返回该块的用户空间地址。 调用 rt_mp_free()函数。将该块内存加入空闲块链表，进行内存的释放。 对内存...
操作系统原理 —— 内存动态分区分配算法（二十一）
贱男
06-07 2081
在上一个章节我们讲了的几种方式，有单一、固定、动态这三种，在固定、动态这种里面，操作系统会记录空闲分区表，这个表是用来记录当前空闲的内存。那么在之后有新的进程装入内存，需要从空闲分区表中找到一块比较合适的空闲内存，该怎么找呢？ 这个就是今天我们要讲解的，几种不同方式的。算法思想：每次都从低地址开始查找，找到第一个能满足大小的空闲分区。如何实现：，每次分配内存时顺序查找空闲分区表或者空闲分区链，找到第一个能满足大小的空闲分区。这个算法很好理解，就从低位置开始找，找到第一个大小符合要求的就行，看下面的例子：在这
"基于区域的Java字节码验证器：内存安全执行和管理
rugina}@ cs.cornell.edu计算机科学系康奈尔大学Ithaca，NY14853摘要本文提出了一种扩展Java字节码的内存安全执行验证器，支持基于区域的内存管理和显式释放原语。验证器读取带区域注释的字节码，这些字节码通过创建...
[网络安全自学篇] 七十六.逆向分析之OllyDbg动态调试工具（二）INT3断点、反调试、硬件断点与内存断点
杨秀璋的专栏
05-13 9264
这是作者网络安全自学教程系列，主要是关于安全工具和实践操作的在线笔记，特分享出来与博友们学习，希望您喜欢，一起进步。前文分享了Vulnhub靶机渗透题目bulldog，包括信息收集及目录扫描、源码解读及系统登陆、命令注入和shell反弹、权限提升和获取flag。这篇文章将讲解逆向分析之OllyDbg动态调试工具，包括INT3断点、反调试、硬件断点和内存断点。基础性文章，希望对您有所帮助。
c# 定位内存快速增长_改善C#程序，提高程序运行效率的50种方法
weixin_39663378的博客
12-20 780
转自：http://blog.sina.com.cn/s/blog_6f7a7fb501017p8a.html一、用属性代替可访问的字段1、.NET数据绑定只支持数据绑定，使用属性可以获得数据绑定的好处；2、在属性的get和set访问器重可使用lock添加多线程的支持。二、readonly(运行时常量)和const(编译时常量)1、const只可用于基元类型、枚举、字符串，而readonly则可以...
我的linux学习之入门到入坟（二十一）-服务管理之httpd
dabaohjl的博客
07-05 215
文章目录## 1. httpd简介2. httpd版本2.1 httpd的特性2.2 httpd-2.4新增的模块3. httpd基础3.1 httpd自带的工具程序3.2 rpm包安装的httpd程序环境3.3 web相关的命令3.3.1 curl命令3.3.2 httpd命令4. 编译安装httpd-2.45. httpd常用配置作业 ## 1. httpd简介 httpd是Apache超文本传输协议（HTTP）服务器的主程序。被设计为一个独立运行的后台进程，它会建立一个处理请求的子进程或线程的池。
函数理解（c）
2403_86949771的博客
10-29 351
这时候就引入了一个新的变量，函数指针变量，定义一个函数指针需要声明它的返回值还有他参数的类型，如int add（int x，int y）这个函数名，用函数指针接受就应该这样写。其实，我们在使用函数时就是调用了他的地址，取地址函数名其实和直接写函数名是本质上是相同的，函数名就是一个地址，当我们使用它时编译器就会去地址中调用它。相信在日常写代码时，函数一定是我们的一个好帮手，它可以帮我们实现各种各样的功能，如简单的排序，比较大小，还有关于字符串的一系列处理。但是在使用函数时空间是如何被调用的呢？
扫雷（C语言）
希望我的博客能帮助你
10-31 1461
本篇文章基于前面的学习内容，有一些部分与前一篇的三子棋一样，可能会比较快，但是写逻辑的和游戏实现的时候会详细讲解，来动手写一个简单的扫雷。我们首先在game.h里定义行和列，以及多两行和多两列的定义。之后再test.c中包含一下这个头文件，这样这里的定义的行和列就可以使用了。接下来首先定义两个数组，一个是mine数组作为还没有进行排查的时候，并且里面布置好了雷的信息，接下来在定义一个排查出雷的信息，命名为show，将两个数组进行初始化。扫雷游戏: C语言版本扫雷游戏 (gitee.com)
嵌入式通信协议：UART简明学习笔记
weixin_73867577的博客
10-31 737
学习UART串口的简明学习笔记
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 612
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
嵌入式通信协议：MODBUS简明学习笔记
最新发布
weixin_73867577的博客
11-02 157
学习Modbus的简明学习笔记
点云学习笔记3——读取点云文件、进行统计滤波/直通滤波后可视化
qq_64095888的博客
10-29 196
【代码】点云学习笔记3——读取点云文件、进行统计滤波后可视化。
STM32动态内存管理：无碎片实现
"MCU动态内存管理是一种在单片机中使用C语言实现的内存管理机制，旨在避免内存碎片并确保高效地分配和释放内存。本文着重介绍如何在STM32单片机上实现分块式的动态内存管理，包括malloc和free函数的实现。 在嵌入式...
评论 39
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HackerKevn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值