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

news/2024/5/17 15:11:08

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

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

📝所属专栏：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,是为了防止内存开辟失败，被置为NULLint* 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;//将指针置为 NULLif (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.mrgr.cn/p/65446277

相关文章

【DL水记】循环神经网络RNN的前世今生，Transformer的崛起，Mamba模型

【DL水记】循环神经网络RNN的前世今生，Transformer的崛起，Mamba模型

文章目录 RNN网络简介传统RNN网络结构RNN的分类 长-短期记忆网络 (LSTM)GRU网络横空出世的Transformer网络Self-AttentionVisionTransformer Mamba模型Reference: RNN网络简介 “当人类接触新事物时&#xff0c;他们不会从头开始思考。就像你在阅读这篇文章时&#xff0c;你会根…
阅读更多...
【读点论文】YOLOX: Exceeding YOLO Series in 2021，无锚框单阶段目标检测方案，解耦检测头的分类和回归分支，优化标签分配策略

【读点论文】YOLOX: Exceeding YOLO Series in 2021，无锚框单阶段目标检测方案，解耦检测头的分类和回归分支，优化标签分配策略

YOLOX: Exceeding YOLO Series in 2021 Abstract 在本报告中&#xff0c;我们介绍了YOLO系列的一些经验改进&#xff0c;形成了一种新的高性能探测器—YOLOX。我们将YOLO检测器切换到无锚方式&#xff0c;并进行其他先进的检测技术&#xff0c;即去耦头和领先的标签分配策略S…
阅读更多...
常用UI组件

常用UI组件

一、文本组件 1.1 概述 Text为文本组件&#xff0c;用于显示文字内容 1.2 参数 Text组件的参数类型为string | Resource Entry Component struct Index {build() {Column({space : 50}) {Text(你好).fontSize(50)}.width(100%).height(100%).justifyContent(FlexAlign.Cent…
阅读更多...
【Entity Framework】闲话EF中批量配置

【Entity Framework】闲话EF中批量配置

【Entity Framework】闲话EF中批量配置 文章目录 【Entity Framework】闲话EF中批量配置一、概述二、OnModelCreating中的批量配置元数据API的缺点 三、预先约定配置忽略类型默认类型映射预先约定配置的限制约定添加新约定替换现有约定约定实现注意事项 四、何时使用每种方法进…
阅读更多...
Rust实现hotkey

Rust实现hotkey

最近想写一个快捷启动工具来满足自己的需求，刚好用自己最喜欢的 Rust 来实现实现方法 文档: global_hotkey 具体代码 use global_hotkey::{hotkey::{Code, HotKey, Modifiers},GlobalHotKeyEvent, GlobalHotKeyManager, HotKeyState, }; use winit::event_loop::{ControlFlow,…
阅读更多...
2024面试软件测试，常见的面试题（上）

2024面试软件测试，常见的面试题（上）

一、综合素质 1、自我介绍 面试官您好&#xff0c;我叫XXX&#xff0c;一直从事车载软件测试&#xff0c;负责最多的是中控方面。 以下是我的一些优势&#xff1a; 车载的测试流程我是熟练掌握的&#xff0c;且能够独立编写测试用例。 平时BUG提交会使用到Jira&#xff0c;类似…
阅读更多...
海外云手机为什么适合社媒运营？

海外云手机为什么适合社媒运营？

如今&#xff0c;社媒营销如果做得好&#xff0c;引流效果好的账号&#xff0c;可以用来带货变现&#xff0c;而外贸、品牌出海也同样都在做社媒营销&#xff0c;Tik Tok、facebook、ins等热门的海外社媒平台都是行业密切关注的&#xff0c;必要的时候&#xff0c;大家会使用海…
阅读更多...
高级IO和5种IO模型

高级IO和5种IO模型

目录 1. 高级IO1.1 IO的基本概念1.2 OS如何得知外设当中有数据可读取1.3 OS如何处理从网卡中读取到的数据包1.4 IO的步骤 2. 五种IO模型2.1 利用钓鱼来理解2.2 阻塞IO2.3 非阻塞IO2.4 信号驱动IO2.5 IO多路转接2.6 异步IO 3. 高级IO的概念3.1 同步通信 VS 异步通信3.2 阻塞 VS …
阅读更多...
FineReport11 报表技巧02- 实现类Excel表头筛选功能

FineReport11 报表技巧02- 实现类Excel表头筛选功能

背景： 在报表开发中，有的需求方用习惯Excel的表头筛选时，就不太习惯帆软的特意点击报表控件进行筛选，希望报表筛选方式可以类似Excel那种直接在表头进行筛选的功能 最终效果如下：实现步骤： 1.1、数据集准备 产品信息表： SELECT 客户,产品,数量,cast(下单时间 as date) a…
阅读更多...
项目冲刺

项目冲刺

项目冲刺汇总 第一天 第二天 会议图片第三天 会议图片第四天 会议图片第五天 会议图片第六天 会议图片第七天 会议图片燃尽图
阅读更多...
正则表达式（Regular Expression）

正则表达式（Regular Expression）

正则表达式很重要&#xff0c;是一个合格攻城狮的必备利器&#xff0c;必须要学会&#xff01;&#xff01;&#xff01; &#xff08;参考视频&#xff09;10分钟快速掌握正则表达式&#xff08;奇乐编程学院&#xff09;https://www.bilibili.com/video/BV1da4y1p7iZ在线测试…
阅读更多...
CommunityToolkit.Mvvm笔记---ObservableValidator

CommunityToolkit.Mvvm笔记---ObservableValidator

ObservableValidator 是实现 INotifyDataErrorInfo 接口的基类&#xff0c;它支持验证向其他应用程序模块公开的属性。 它也继承自 ObservableObject&#xff0c;因此它还可实现 INotifyPropertyChanged 和 INotifyPropertyChanging。 它可用作需要支持属性更改通知和属性验证的…
阅读更多...
MyBatis 中的动态 SQL 的相关使用方法

MyBatis 中的动态 SQL 的相关使用方法

为什么会有动态SQL&#xff0c;把SQL写死不是比较方便吗&#xff1f;其实有很多的举例&#xff0c;这里我那一个常见的来说&#xff0c;像我们用户注册&#xff0c;会有必填字段和非必填字段&#xff0c;有些传来的参数不一样&#xff0c;那对应的SQL也不一样&#xff0c;因此&…
阅读更多...
HarmonyOS NEXT应用开发之下拉刷新与上滑加载案例

HarmonyOS NEXT应用开发之下拉刷新与上滑加载案例

介绍 本示例介绍使用第三方库的PullToRefresh组件实现列表的下拉刷新数据和上滑加载后续数据。 效果图预览使用说明进入页面，下拉列表触发刷新数据事件，等待数据刷新完成。 上滑列表到底部，触发加载更多数据事件，等待数据加载完成。实现思路使用第三方库pullToRefresh组件，…
阅读更多...
基于51单片机的自行车测速里程码表设计( proteus仿真+程序+设计报告+原理图+讲解视频）

基于51单片机的自行车测速里程码表设计( proteus仿真+程序+设计报告+原理图+讲解视频）

基于51单片机的自行车测速里程码表设计 1. 主要功能&#xff1a;2. 讲解视频&#xff1a;3. 仿真设计4. 程序代码5. 设计报告6. 原理图7. 设计资料内容清单资料下载链接&#xff1a; 基于51单片机的自行车测速里程码表设计( proteus仿真程序设计报告原理图讲解视频&#xff09;…
阅读更多...
Redis Cluster 集群部署

Redis Cluster 集群部署

目录一、什么是redis Cluster集群二、集群架构图三、redis Cluster部署架构1、测试环境2、生产环境四、原生命令手动部署Redis Cluster1、环境准备2、为所有节点启用redis集群支持3、执行meet操作实现互相通信在任意一节点上和其它所有节点进行meet通信，以m1为例4、为每个mast…
阅读更多...
2024-9.python文件操作

2024-9.python文件操作

文件操作 引言 到目前为止&#xff0c;我们做的一切操作&#xff0c;都是在内存里进行的&#xff0c;这样会有什么问题吗&#xff1f;如果一旦断电或发生意外关机了&#xff0c;那么你辛勤的工作成果将瞬间消失。是不是感觉事还挺大的呢&#xff1f;现在你是否感觉你的编程技…
阅读更多...
第七天博客

第七天博客

第七天随笔 会议照昨天工作完成总结 黄永名： 今天的测试人员测出了一些bug，有关于sql语句的。不过文档有点不太直观，细致的看了一下。出现了无法通过作者名检索书籍的情况，于是在数据库上用sql语句测试了一下，并没有出现问题。还有很多类似这样的情况，比如无法注册管理员…
阅读更多...
conda安装好了虚拟环境，可以在pycham里导入xpotato库，但是在jupyter notebook中却导入不了

conda安装好了虚拟环境，可以在pycham里导入xpotato库，但是在jupyter notebook中却导入不了

问题描述 使用conda安装好了虚拟环境&#xff0c;可以在pycham里导入xpotato库&#xff0c;但是在jupyter notebook中却导入不了 原因 虽然是在anaconda Prompt的环境中进入的Jupyter Notebook&#xff0c;但是Jupyter Notebook的默认内核却不是那个环境&#xff0c;需要重新更…
阅读更多...
atri

atri

阅读更多...
推荐文章

Copyright @ 2022~2023