「探索C语言内存：动态内存管理解析」

news2024/12/25 0:47:19

🌠先赞后看，不足指正!🌠

🎈这将对我有很大的帮助！🎈

📝所属专栏：C语言知识

📝阿哇旭的主页：Awas-Home page

目录

 

引言

1. 静态内存

2. 动态内存

2.1 动态内存开辟函数

2.1.1 malloc函数

2.1.2 calloc函数

2.1.3 realloc函数

2.2 动态内存释放函数

2.2.1 free函数

3. 动态内存的常见错误

3.1 对NULL指针的解引用

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

3.3 对非动态开辟内存使用free释放

3.4 使用free释放一块动态开辟内存的一部分

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

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

4. 动态内存管理经典题目分析

4.1 出现悬空指针和访问无效内存

4.2 局部变量的生命周期

4.3 内存开辟后未释放

4.4 内存释放后再次使用

5. 柔性数组

5.1 柔性数组是什么

5.2 柔性数组的特点

5.3 柔性数组的使用

5.4 柔性数组的优势

6. 在C/C++中程序内存区域划分

7. 总结

引言

        什么是内存？内存，也称为主存或随机存储器（RAM），是计算机中用于存储数据和程序的临时存储设备。在下文中，我将讲解到内存的开辟方式，分为静态内存开辟和动态内存开辟两部分。

        那么，话不多说，我们一起来看看吧！

1. 静态内存

        在前面的学习中，我们掌握的内存开辟方式有两种：

#include<stdio.h>
int main()
{
    int val = 20;      //1. 在栈空间上开辟 4 个字节
    char a[10] = { 0 };//2. 在栈空间开辟 10 个字节的连续空间
    return 0;
}

        但静态内存开辟的内存空间会存在一定的缺陷：

  • 空间开辟大小是固定的。
  • 数组在声明的时候，必须指定数组的长度，数组空间一旦确定了大小是不能调整的。 

2. 动态内存

        为了解决静态内存开辟的内存空间所存在的问题。为此，C语言中引入了动态内存开辟，让程序员可以手动管理内存，包括分配和释放内存空间，这样就比较灵活了。

2.1 动态内存开辟函数

2.1.1 malloc函数

（1）头文件：在标头<stdlib.h>中定义

（2）函数原型：void* malloc (size_t size);

  • size_t 是一个无符号整数类型，size 表示需要分配的字节数。
  • 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

（3）作用：向内存申请一块连续可用的空间，并返回指向这块空间的指针。

  • 开辟成功时，返回指向新分配内存的指针。
  • 开辟失败时，返回空指针（NULL），因此 malloc 的返回值一定要做检查。

（4）返回值：该函数返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候由使用者来确定。

补充：perror函数

（1）头文件：在标头<stdio.h>中定义

（2）函数原型：void perror(const char *s);

  • 如果s为NULL，则只输出错误信息而不输出自定义信息。

（3）作用：用于将错误码转换为对应的错误信息并输出到标准错误流(stderr)中。

（4）返回值：无返回值。

#include <stdio.h>
#include <errno.h>

int main() {
	FILE* fp = fopen("file.txt", "r");
	if (fp == NULL) {
		perror(fp);
	}
	return 0;
}

运行结果：

malloc 函数的具体使用举例：

int main()
{
	//开辟一个大小为10个整形的空间
	//返回值类型强制转换为 （int*）
	int* arr = (int*)malloc(10 * sizeof(int));
	if (arr == NULL)//开辟空间失败
	{
		perror("malloc failed");//打印错误信息
		return 1;//返回
	}

	int i = 0;
	//读取存入数据
	for (i = 0; i < 10; i++)
	{
		arr[i] = i + 1;
	}

	//打印输出数据
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

输出结果：

监视窗口：读取存入数据

  • 动态存储的数据存放在内存的堆区。 

2.1.2 calloc函数

（1）头文件：在标头<stdlib.h>中定义

（2）函数原型：void* calloc (size_t nitems, size_t size);

  • nitems表示要分配的元素个数。
  • size 表示元素的大小。

（3）作用：分配所需的空间，并返回指向这块空间的指针。

（4）返回值：函数返回一个指向新分配的内存空间的指针，如果分配失败则返回NULL。

        calloc函数与malloc函数类似，不同之处在于calloc函数会在分配内存空间后将其初始化为0，而malloc函数不会做这个操作。因此，如果需要分配一段内存空间并将其初始化为0，可以使用calloc函数。

calloc 函数的具体使用举例：

int main()
{
	//开辟一个大小为十个整形的空间
	//返回值类型强制转换为 int*
	int* arr = (int*)calloc(10, sizeof(int));
	if (arr == NULL)//开辟空间失败
	{
		perror("calloc failed");//打印错误信息
		return 1;//返回
	}

	return 0;
}

监视窗口：项全初始化为 0

2.1.3 realloc函数

（1）头文件：在标头<stdlib.h>中定义

（2）函数原型：void *realloc(void *ptr, size_t size);

  • ptr 表示要重新分配内存空间的指针。
  • size 表示新分配的内存空间大小。

（3）作用：用于调整 malloc 或 calloc 所分配的 ptr 指向已经分配的内存空间大小。

（4）返回值：函数返回一个指向新分配的内存空间的指针，如果分配失败则返回NULL。

  1.  realloc函数的出现让动态内存管理更加灵活。
  2. 有时会我们发现过去申请的空间太小或太大了，那么为了合理利用内存，我们会对内存的大小做一些灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
  3. realloc 函数的扩容机制：
  • 原有空间扩容：原有空间之后有足够大的空间，直接在原有内存之后直接追加空间，原来空间的数据不发生变化。
  • 新开空间扩容：原有空间之后没有足够大的空间，在堆空间上另找⼀个合适大小的连续空间来使用。同时将新增数据和原有数据拷贝到新的空间，并释放原有空间。

realloc 函数的具体使用举例： 

int main()
{
	//开辟一个大小为十个整形的空间
	//返回值类型强制转换为 int*
	int* arr = (int*)calloc(10, sizeof(int));
	if (arr == NULL)//开辟空间失败
	{
		perror("calloc failed");//打印错误信息
		return 1;//返回
	}

	//扩大空间
	//不使用int* arr,是为了防止内存开辟失败，被置为NULL
	int* tmp = (int*)realloc(arr, 80 * sizeof(int));
	if (tmp == NULL)//开辟空间失败
	{
		perror("realloc failed");//打印错误信息
		return 1;//返回
	}

	arr = tmp;

	return 0;
}

  • 当新增内存比较小时，一般是在原有空间基础上开辟新的空间。二者的地址相同。 
int* tmp = (int*)realloc(arr, 80 * sizeof(int));

  •  当新增内存比较大时，则会开辟一个新的空间，并将原有空间释放。二者的地址不同。

2.2 动态内存释放函数

2.2.1 free函数

        我们要知道，动态开辟的空间不会像静态开辟的空间那样随程序的结束就自动回收。这就需要我们去手动回收，避免造成内存泄漏。

  • 内存泄漏是指程序在运行过程中，动态分配的内存空间没有被释放，导致该内存空间一直被占用，无法被其他程序使用，从而造成内存资源的浪费。如果内存泄漏严重，会导致程序崩溃或者操作系统崩溃。

（1）头文件：在标头<stdlib.h>中定义

（2）函数原型：void free(void *ptr);

  • ptr 是指向之前分配的内存空间的指针。调用 free 函数会释放该内存空间，使其可以被重新使用。

（3）作用：用于释放之前通过 malloc、calloc、realloc 等函数动态分配的内存空间。

（4）返回值：无返回值。

free 函数的具体使用举例：

int main()
{
	//开辟一个大小为十个整形的空间
	//返回值类型强制转换为 int*
	int* arr = (int*)calloc(10, sizeof(int));
	if (arr == NULL)//开辟空间失败
	{
		perror("calloc fail");//打印错误信息
		return 1;//返回
	}

	//扩大空间
	int* tmp = (int*)realloc(arr, 20 * sizeof(int));
	if (tmp == NULL)//开辟空间失败
	{
		perror("realloc fail");//打印错误信息
		return 1;//返回
	}

	arr = tmp;
	free(arr);//释放arr所指向的动态内存
	arr = NULL;

	return 0;
}
  •  在使用free函数释放动态分配的内存空间之后，将指针置为NULL是一种良好的编程习惯，可以避免悬空指针的问题。
  • 悬空指针是指已经被释放的内存空间的指针，如果在指针被释放后继续使用该指针，就会导致未定义的行为。将指针置为NULL可以避免这种情况的发生，因为在使用空指针时，程序会抛出异常或崩溃，从而提醒程序员出现了问题。

3. 动态内存的常见错误

        动态内存的管理和指针类似，利用不当会出现错误，以下是一些常见错误的例子：

3.1 对NULL指针的解引用

void test()
{
    int* pf = (int*)malloc(INT_MAX / 4);
    *pf = 20; //如果p的值是NULL，就会有问题 
    free(pf);
}
  • INT_MAX 是一个宏定义（常量），表示的是整型数据类型的最大值，一般情况下是 2147483647。
  • 当 malloc 函数申请的空间过大时，则会出现空间开辟失败的情况，此时返回空指针（NULL）。
  • 编译器无法访问空指针（NULL），此时编译器会报错。

正确方法：

void test()
{
    int* pf = (int*)malloc(INT_MAX / 4);
    if (pf == NULL)
    {
        perror("malloc failed!");
        return 1;
    }
    *pf = 20; //如果p的值是NULL，就会有问题 

    free(pf);
    pf = NULL;
}
  • 综上，检查开辟的空间是否为空指针是十分重要的。 

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

void test()
{
    int i = 0;
    int* pf = (int*)malloc(10 * sizeof(int));
    if (pf == NULL)
    {
        perror("malloc failed!");
        return 1;
    }
    for (i = 0; i <= 10; i++)
    {
        *(pf + i) = i;//当i是10的时候越界访问 
    }
    free(pf);
    pf = NULL;
}
  • malloc函数只申请了10个整型大小空间的内存。
  • for循环循环访问来十一次空间，造成越界访问，错误信息如下：

正确方法：

void test()
{
    int i = 0;
    int* pf = (int*)malloc(10 * sizeof(int));
    if (pf == NULL)
    {
        perror("malloc failed!");
        return 1;
    }
    for (i = 0; i <= 10; i++)
    {
        *(pf + i) = i;//当i是10的时候越界访问 
    }
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *(pf + i));
    }
    free(pf);
    pf = NULL;
}

3.3 对非动态开辟内存使用free释放

void test()
{
    int a = 10;
    int* pf = &a;
    free(pf);//是否可行？
}
  • free函数，是专门用来做动态内存的释放和回收的。
  • 指针 pf 所指向的空间是静态内存开辟的，若强行释放，编译器就会报错：

正确方法：

void test()
{
    int a = 10;
    int* pf = &a;
}
  • 静态内存开辟的空间在程序结束时会自动释放回收。 

3.4 使用free释放一块动态开辟内存的一部分

void test()
{
    int* pf = (int*)malloc(100);
    pf++;
    free(pf);//p不再指向动态内存的起始位置 
    pf = NULL;
}
  • pf++ 后，pf 指向的地址增加了一个 int 类型的大小，这样 pf 不再指向动态内存的起始位置，而是指向了动态分配的内存块的下一个 int 类型的位置。
  • free() 函数只能释放动态分配的内存空间的起始位置，而不能释放中间或结尾位置的内存。

正确方法：

void test()
{
    int* pf = (int*)malloc(100);
    free(pf);//p不再指向动态内存的起始位置 
    pf = NULL;
}
  • 注意：不要随意改变 pf 所指向的位置，开辟多少内存就释放多少内存。

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

void test()
{
    int* pf = (int*)malloc(100);
    free(pf);
    free(pf);//重复释放 
}
  • 重复使用 free() 函数尝试释放 pf 所指向的内存空间。这是一个错误的操作，因为在第一次调用 free() 函数后，内存空间已经被释放，pf 指向的内存不再有效。
  • 重复释放已经释放的内存空间会导致程序运行时出现未定义行为，可能会导致内存错误或程序崩溃。

正确方法：

void test()
{
    int* pf = (int*)malloc(100);
    free(pf);
    pf = NULL;
}
  •  在每次释放完内存后，将 pf 设置为 NULL，可以避免出现悬空指针（dangling pointer）的问题。

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

void test()
{
    int* pf = (int*)malloc(100);
    if (pf != NULL)
    {
        *pf = 20;
    }
}
  •  在申请的空间使用完毕后，应该使用 free() 函数释放动态分配的内存空间。避免内存泄漏。

正确方法：

void test()
{
    int* pf = (int*)malloc(100);
    if (pf != NULL)
    {
        *pf = 20;
    }
    free(pf);
    pf = NULL;
}

4. 动态内存管理经典题目分析

4.1 出现悬空指针和访问无效内存

问题一：

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}

错误：

  • 在 GetMemory 函数中，p 是一个指针的拷贝，当在函数内部对 p 进行赋值（分配内存）时，只是修改了拷贝的值，并不会影响原始指针 str。
  • 在 Test 函数中，尝试使用未分配有效内存空间的 str 指针来存储字符串 "hello world"，这将导致未定义行为，可能会导致程序崩溃。

        正确方法：

  1. 我们要想改变 str 就需要传址调用，而 str 本身就是个指针变量，传指针变量的地址需要二级指针来接收。
  2. 使用完之后必须释放内存。
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
 
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	free(str);//释放
	str = NULL;
}

4.2 局部变量的生命周期

问题二：

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

错误： 

  1. 在函数 GetMemory 中，数组 p 是一个局部数组，它的生命周期仅限于函数 GetMemory 的执行期间。当函数返回后，p的内存空间将被释放，因此返回的指针将指向无效的内存区域，这是一种未定义行为。
  2. 为了避免这些问题，应该避免返回局部变量的地址。如果需要在函数中动态分配内存并返回指针，可以使用 malloc 分配内存，然后在适当的时候释放这块内存。

        正确方法：

char* GetMemory(void)
{
    char* p = (char*)malloc(12);//分配足够的内存空间，包括字符串结束符
    if (p == NULL)
    {
        perror("malloc fail!");
        return 1;
    }
    strcpy(p, "hello world");
    return p;
}

void test(void)
{
    char* str = NULL;
    str = GetMemory();
    if (str != NULL)
    {
        printf("%s", str);
        free(str); // 释放内存
    }
}

4.3 内存开辟后未释放

问题三：

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}

void test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}

        错误：上面的代码，可以正常的运行。但要注意的是，程序动态开辟内存后未释放回收，造成内存泄漏。

正确方法：

void test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
	free(str);
	str = NULL;
}

4.4 内存释放后再次使用

问题四：

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);//?
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

        错误：运行上述代码，我们会发现，这是一个经典的野指针问题，由于 str 指向的内存空间已经被释放，再次调用 strcpy 函数向其写入字符串 "world" 会导致问题。

正确方法：

        内存释放后，将其置为 NULL （空指针），使后续语句不再执行。

void test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	str = NULL;//将指针置为 NULL
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

5. 柔性数组

5.1 柔性数组是什么

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

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

        有些编译器会报错无法编译可以换一种写法：

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

5.2 柔性数组的特点

  • 结构中的柔性数组成员前面必须至少⼀个其他成员。
  • sizeof 返回的这种结构大小不包括柔性数组的内存。
typedef struct st_type
{
 int i;
 int a[0];//柔性数组成员 
}type_a;
int main()
{
 printf("%zd\n", sizeof(type_a));
 return 0;
}

  • 包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

5.3 柔性数组的使用

         柔性数组的使用与结构体十分相似，具体例子如下：

// 定义柔性数组的结构体
typedef struct FlexArray 
{
    int len; // 数组的长度
    int data[]; // 可变长度的整型数组
}type_a;
int main() 
{
    int len = 100; // 柔性数组的长度
    // 动态分配内存空间
    type_a* flexArray = malloc(sizeof(type_a) + len * sizeof(int));
    if (flexArray == NULL)
    {
        perror("malloc fail!");
        return 1;
    }
    flexArray->len = len;
    // 输出柔性数组的长度
    printf("柔性数组的长度: %d\n", flexArray->len);
    // 释放内存
    free(flexArray);
    flexArray = NULL;

    return 0;
}

  •  这样柔性数组成员 data，相当于获得了100个整型元素的连续空间。

具体使用如下：

#include <stdio.h>
#include <stdlib.h>

// 定义柔性数组的结构体
typedef struct FlexArray 
{
    int len; // 数组的长度
    int data[]; // 可变长度的整型数组
}type_a;
int main() 
{
    int len = 100;
    // 动态分配内存空间
    type_a* pf = malloc(sizeof(type_a) + len * sizeof(int));
    if (pf == NULL)
    {
        perror("malloc fail!");
        return 1;
    }
    pf->len = 100;
    //为柔性数组赋值
    for (int i = 0; i < 100; i++)
    {
        pf->data[i] = i;
    }
    //输出柔性数组的值
    printf("柔性数组的值: ");
    for (int i = 0; i < pf->len; i++)
    {
        printf("%d ", pf->data[i]);
    }
    printf("\n");
    //释放内存
    free(pf);
    pf = NULL;
    return 0;
}

5.4 柔性数组的优势

  • 访问元素方便：由于柔性数组是结构体的一部分，因此可以通过结构体指针直接访问柔性数组的元素，而不需要额外的指针操作。
  • 提高访问速度：由于柔性数组在内存中是连续存储的，可以提高数据的访问速度，从而提高程序的性能。
  • 内存管理效率：柔性数组允许将结构体和数组的内存分配在一次连续的操作中完成，这有助于减少内存碎片化，提高内存管理的效率。

6. 在C/C++中程序内存区域划分

        在 C/C++ 程序中，内存区域通常被划分为以下几个部分：

栈区（Stack）：

  • 栈区用于存储函数的局部变量、函数参数、函数调用的返回地址等。
  • 栈区是一种后进先出的数据结构，每次函数调用时会在栈上分配一块内存空间，函数返回时会释放该空间。
  • 栈区的大小是有限的，通常在编译时确定，如果栈区溢出会导致程序崩溃。

堆区（Heap）：

  • 堆区用于动态分配内存，程序员可以通过 malloc、calloc 等函数在堆上分配内存。
  • 堆区的大小通常比栈区大得多，可以根据需要动态地分配和释放内存。
  • 堆区的内存由程序员手动管理，需要注意避免内存泄漏和内存访问越界等问题。

全局区/静态区（Global/Static）：

  • 全局区用于存储全局变量、静态变量、常量等。
  • 全局区在程序启动时分配，在程序结束时释放。
  • 全局变量和静态变量的生命周期与程序的运行周期相同，常量存储在只读内存区域。

7. 总结

        希望这篇文章对大家有所帮助，如果你有任何问题和建议，欢迎在评论区留言，这将对我有很大的帮助。

        完结！咻~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1607798.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Windows远程桌面连接虚拟机Linux

Windows远程桌面连接虚拟机Linux

Windows远程桌面连接虚拟机Linux 需要先打开虚拟机的启用VNC连接使用VNC客户端进行连接 yum install -y tigervnc-server #安装tigervnc-server vncserver #启动一个vnc进程 #第一次启动会要求设置密码 #如果需要更改密码可以使用vncpasswd进行更改密码 vncserver -list #查看…
阅读更多...
【Linux实践室】Linux高级用户管理实战指南：Linux用户与用户组编辑操作详解

【Linux实践室】Linux高级用户管理实战指南：Linux用户与用户组编辑操作详解

&#x1f308;个人主页&#xff1a;聆风吟_ &#x1f525;系列专栏&#xff1a;Linux实践室、网络奇遇记 &#x1f516;少年有梦不应止于心动&#xff0c;更要付诸行动。 文章目录 一. ⛳️任务描述二. ⛳️相关知识2.1 &#x1f514;Linux查看用户属性命令2.1.1 &#x1f47b;…
阅读更多...
数据结构-上三角矩阵存储方式[0知识掌握]

数据结构-上三角矩阵存储方式[0知识掌握]

目标&#xff1a;看完本文章你将会了解上三角矩阵的存储方式以及矩阵中数据的位置索引号如何求 难点&#xff1a;上三角矩阵的公式推导&#xff0c;上三角任意位置对应的存储位置。 一、准备知识 1.求和公式 前n项和&#xff1a;Sn n(a1an)/2 公差&#xff1a;d后项-前项…
阅读更多...
易保全网络赋强公证系统，前置预防、快速化解债权纠纷

易保全网络赋强公证系统，前置预防、快速化解债权纠纷

网络赋强公证是一种创新的法律服务模式&#xff0c;为金融机构和债权人提供了一种便捷、高效的债权保障方式。既可以加大对违约方的司法震慑力&#xff0c;又能降低维权方实现债权的风险&#xff0c;且执行时间更快&#xff0c;债权周期更短&#xff0c;诉讼费用更低&#xff0…
阅读更多...
OpenHarmony鸿蒙南向开发案例：【智能燃气检测设备】

OpenHarmony鸿蒙南向开发案例：【智能燃气检测设备】

样例简介 本文档介绍了安全厨房案例中的相关智能燃气检测设备&#xff0c;本安全厨房案例利用轻量级软总线能力&#xff0c;将两块欧智通V200Z-R/BES2600开发板模拟的智能燃气检测设备和燃气告警设备组合成。当燃气数值告警时&#xff0c;无需其它操作&#xff0c;直接通知软总…
阅读更多...
【机器学习】分类与预测算法评价的方式介绍

【机器学习】分类与预测算法评价的方式介绍

一、引言 1、机器学习分类与预测算法的重要性 在数据驱动的时代&#xff0c;机器学习已经成为了处理和分析大规模数据的关键工具。分类与预测作为机器学习的两大核心任务&#xff0c;广泛应用于各个领域&#xff0c;如金融、医疗、电商等。分类算法能够对数据进行有效归类&…
阅读更多...
登录解析(前端)

登录解析(前端)

登录代码 1、登录之后做了什么&#xff1f; 执行登陆方法&#xff0c;成功之后&#xff0c;路由跳转到指定路径或者根目录 2、this.$store.dispatch是什么意思&#xff1f; this.$store.dispatch(‘Login’, this.loginForm) 来调取store里的user.js的login方法3、this.$r…
阅读更多...
调试软件iic协议心得

调试软件iic协议心得

如何判断发送成功&#xff1f; 主控发送了一个字节8位&#xff08;8个 SCL 时钟&#xff09;的数据后&#xff0c;在第9个时钟周期&#xff0c;释放 SDA 控制权&#xff08;IO 引脚输出改为输入&#xff09;&#xff0c;读取 SDA 状态&#xff0c;读到低电平表示通信成功&…
阅读更多...
聊聊路径规划算法（四）——滚动在线RRT算法和BUG算法

聊聊路径规划算法（四）——滚动在线RRT算法和BUG算法

基本RRT算法更偏向于遍历所有自由空间直到获取可行路由性&#xff0c;这使得它不能够进行未知或动态环境条件中的机器人实时运动计划。利用滚动计划的思路可以将RRT算法加以完善&#xff0c;使之更具有实时规划能力。 滚动规划 机器人在不确定的或动态周围环境中行走时&#x…
阅读更多...
面试题集中营—GC日志简析及频繁GC的调优

面试题集中营—GC日志简析及频繁GC的调优

如何查看GC日志 有两种方式查看GC日志&#xff0c;一种是动态命令行查看 jstat -gc <pid> 300 5 第二种就是在JVM参数中增加打印的参数&#xff0c;如下&#xff1a; -XX:PrintGCDetails -XX:PrintGCTimeStamps 表示打印每次GC的日志以及GC发生的时间 -Xloggc:gc.log …
阅读更多...
LeetCode:203.移除链表元素

LeetCode:203.移除链表元素

&#x1f3dd;1.问题描述&#xff1a; &#x1f3dd;2.实现代码&#xff1a; typedef struct ListNode ListNode; struct ListNode* removeElements(struct ListNode* head, int val) {if(headNULL)return head;ListNode *NewHead,*NewTail;ListNode *pcurhead;NewHeadNewTail…
阅读更多...
电动机保护器在电力系统中的重要性

电动机保护器在电力系统中的重要性

摘要&#xff1a;在工业自动化领域&#xff0c;低压电动机广泛应用于各种机械设备&#xff0c;例如传动系统、生产线和泵。为了保证这些设备的正常运行&#xff0c;对低压电动机进行必要的保护至关重要。本文将详细介绍低压电动机的七种保护方式&#xff0c;包括过载保护、短路…
阅读更多...
spring security登录认证授权

spring security登录认证授权

spring security登录认证授权 是什么 Spring Security 主要实现了Authentication&#xff08;认证&#xff0c;解决who are you? &#xff09; 和 Access Control&#xff08;访问控制&#xff0c;也就是what are you allowed to do&#xff1f;&#xff0c;也称为Authorizat…
阅读更多...
基于ssm汽车租赁系统业务管理子系统论文

基于ssm汽车租赁系统业务管理子系统论文

系统简介 随着信息互联网购物的飞速发展&#xff0c;一般企业都去创建属于自己的管理系统。本文介绍了汽车租赁系统业务管理子系统的开发全过程。通过分析企业对于汽车租赁系统业务管理子系统的需求&#xff0c;创建了一个计算机管理汽车租赁系统业务管理子系统的方案。文章介…
阅读更多...
【MySQL 数据宝典】【内存结构】- 005 Log Buffer

【MySQL 数据宝典】【内存结构】- 005 Log Buffer

Log Buffer Log Buffer&#xff1a;日志缓冲区&#xff0c;用来保存要写入磁盘上log文件&#xff08;Redo/Undo&#xff09;的数据&#xff0c;日志缓冲区的内容定期刷新到磁盘log文件中。日志缓冲区满时会自动将其刷新到磁盘&#xff0c;当遇到BLOB或多行更新的大事务操作时&…
阅读更多...
【智能排班系统】Quartz结合Cron-Utils自定义时间发送上班、休息提醒

【智能排班系统】Quartz结合Cron-Utils自定义时间发送上班、休息提醒

文章目录 Quartz&#xff1a;强大的Java作业调度引擎Quartz概述核心概念与架构配置文件主配置&#xff08;配置主要调度器设置、事务&#xff09;线程池配置&#xff08;调整作业执行资源&#xff09;SimpleThreadPool特定属性自定义线程池 RAMJobStore配置&#xff08;在内存中…
阅读更多...
C# 窗体应用程序 Chart控件显示实时曲线

C# 窗体应用程序 Chart控件显示实时曲线

IDE: VS2019 项目模板&#xff1a;C# windows 窗体应用(.NET Framework) 【参考】 B站上教程C#Chart控件画折线图的使用&#xff0c;关于Chart控件的属性&#xff0c;介绍得非常详细。B站上教程C#上位机Chart控件实时曲线终极讲解&#xff0c;对鼠标滚轮事件等&#xff0c;多…
阅读更多...
NLP任务全览：涵盖各类NLP自然语言处理任务及其面临的挑战

NLP任务全览：涵盖各类NLP自然语言处理任务及其面临的挑战

自然语言处理(Natural Language Processing, 简称NLP&#xff09;是计算机科学与语言学中关注于计算机与人类语言间转换的领域。NLP将非结构化文本数据转换为有意义的见解&#xff0c;促进人与机器之间的无缝通信&#xff0c;使计算机能够理解、解释和生成人类语言。人类等主要…
阅读更多...
基于SkyEye运行Qt：著名应用程序开发框架

基于SkyEye运行Qt：著名应用程序开发框架

Qt是一个著名的跨平台的C图形用户界面应用程序开发框架&#xff0c;目前包括Qt Creator、Qt Designer等等快速开发工具&#xff0c;还支持2D/3D图形渲染、OpenGL&#xff0c;允许真正的组件编程&#xff0c;是与GTK、MFC、OWL、ATL一样的图形界面库。使用Qt开发的软件可以做到一…
阅读更多...
excel 无法正确处理 1900-03-01 前的日期

excel 无法正确处理 1900-03-01 前的日期

问题由来&#xff1a;excel 用公式 TEXT(A1,"yyyy-mm-dd") 转日期时&#xff0c;当A1 的值等于59 的时候&#xff0c;返回值是1900-02-28&#xff1b;当A1 的值等于61 的时候&#xff0c;返回值是1900-03-01&#xff1b;那么当 A1的值为 60 的时候&#xff0c;返回值…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023