QT 学习笔记_qt 句柄-CSDN博客

本文链接：https://blog.csdn.net/big_lovely/article/details/140354556

1. 背景

从java转c/c++，逻辑和java同的。

此篇学习笔记，是为了梳理c与java区别之处，包含但不限于相关概念，常用方法等。

2. 基础概念

2.1 句柄

所谓的句柄很好理解，说白了就是一个void *类型的指针。我们利用这个指针，通过强制类型转换，可很好的实现高内聚低耦合的特性。

例：

typedef void *aht20_handle_t; //这个就是句柄，对外可见

2.2 TCB

TCB就是句柄通过强制类型转换之后的结构类型指针，TCB和句柄指向的是同一个区域。

例：

typedef struct
{
	i2c_port_t bus;
	uint8_t dev_addr;
	// ...
}aht20_dev_t;  //这个就是TCB，只有aht20.c文件可以使用，对外不可见

句柄和TCB两者的区别如下：
<1>TCB是不对外可见，只有当前文件可以使用。而句柄是对外可见的。
<2>句柄是一个void *类型的指针，不能直接操作。TCB是一个具象的结构体指针，可以直接操作。

2.3 RAII

2.3.1 介绍

RAII是Resource Acquisition Is Initialization的缩写，即“资源获取即初始化”。它是C++语言的一种管理资源、避免资源泄漏的惯用法，利用栈的特点来实现，这一概念最早由Bjarne Stroustrup提出。在函数中由栈管理的临时对象，在函数结束时会自动析构，从而自动释放资源，因此，我们可以通过构造函数获取资源，通过析构函数释放资源。即：

Object() {
    // acquire resource in constructor
}

~Object() {
    // release resource in destructor
}

RAII总结如下：

将每一种资源封装在一个RAII类中：

所有资源在构造函数中获取，例如：分配内存、打开文件、建立数据库连接等；如果无法完成则在构造函数中抛出异常；
所有资源在析构函数中释放，例如：释放内存、关闭文件、销毁数据库连接等；不应该抛出任何异常。

通过RAII类实例获取资源：

具有自动生命管理周期或临时对象生命周期
其生命周期与第一种绑定。

2.3.2 为什么要用

在这段代码中，new运算符在计算机内存的堆上申请了一块Foo类型的内存，然后将其地址赋值给存储在栈上的指针ptr。为了能够释放内存资源，我们需要使用完new运算符申请的内存后，手动调用delete运算符释放内存。

但是，情况并不总是如此简单。

Foo* ptr = new Foo(1);

f(ptr);  // -->① may throw exception
if(ptr->g()) {
    // ... --> ② may forget to delete ptr
    return;
}
// ...
delete ptr;

如上面这个例子，我们可能会遇到以下几种情况：

忘记delete释放内存。比如释放原指针指向的内存前就改变了指针的指向。
程序抛出异常后导致无法delete。比如上面的①处，如果f函数抛出异常，没有机会运行delete，从而导致内存泄漏。
需求变更后，修改了函数，新增了分支，提前返回，却没有delete；现实情况代码复杂的话可能没有这么显而易见。

而通过RAII这样一种机制，我们可以使其自动释放内存。

2.3.3 C++ STL中RAII的应用

2.3.3.1 智能指针

智能指针是RAII的一种实现，它是一种模板类，用于管理动态分配的对象。智能指针的主要作用是自动释放内存，从而避免内存泄漏。C++11中提供了三种智能指针：unique_ptr、shared_ptr和weak_ptr。它们的详细原理将在之后的文章中介绍。这里我们以unique_ptr为例，它的构造函数如下：

template< class T, class Deleter = std::default_delete<T> > class unique_ptr;

unique_ptr的析构函数会自动释放内存，因此，我们可以通过unique_ptr来管理动态分配的内存，从而避免内存泄漏。例如：

std::unique_ptr<int> ptr = std::make_unique<int>(1); // release memory when ptr is out of scope

2.3.3.2 互斥锁

在多线程编程中，std::lock_guard, std::unique_lock, std::shared_lock等也利用了RAII的原理，用于管理互斥锁。当这些类的等对象创建时，会自动获取互斥锁；当对象销毁时，会自动释放互斥锁。

std::lock_guard的构造函数如下：

template< class Mutex > class lock_guard;

std::lock_guard的析构函数会自动释放互斥锁，因此，我们可以通过std::lock_guard来管理互斥锁，从而避免忘记释放互斥锁。例如：

std::mutex mtx;
std::lock_guard<std::mutex> lock(mtx); // unlock when lock is out of scope

不使用RAII的情况下，我们需要手动释放互斥锁，如下所示：

std::mutex mtx;
mtx.lock();
// ...
mtx.unlock();

2.3.3.3 文件操作

std::ifstream, std::ofstream等C++标准库的IO操作都是RAII的实现。

2.3.3.4 事务处理

数据库事务处理中，如果在事务结束时没有提交或回滚，就会导致数据库连接一直被占用，从而导致数据库连接池耗尽。因此，我们需要在事务结束时自动提交或回滚，从而释放数据库连接。这一过程也可以通过RAII来实现。

2.3.3.5 其他

RAII还可以用于管理其他资源，比如网络连接、线程等。

2.4 堆栈

2.4.1 介绍

"new运算符在计算机内存的堆上申请了一块Foo类型的内存，然后将其地址赋值给存储在栈上的指针ptr。" 在这里其实已经引入了堆和栈的概念。

在C语言中的四大存储区。

栈，由编译器自动分配释放
堆，一般由程序员分配释放，若程序员不释放，程序结束时由OS回收。
全局区（静态区），全局变量和静态变量的存放是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另外一块区域。程序结束进行释放。
常量区，程序结束释放。

int a = 0; 全局初始化区
char *p1; 全局未初始化区
main()
{
	int b; //栈
	char s[] = "abc ";//指针常量s在栈区，"abc "在常量区
	char *p2; //栈
	char *p3 = "123456 "; //123456\0在常量区，p3在栈上。
	static int c =0； //全局（静态）初始化区
    //分配得来得10和20字节的区域就在堆区。
	p1 = (char *)malloc(10);
	p2 = (char *)malloc(20);
	
    strcpy(p1, "123456 "); //123456\0放在常量区，编译器可能会将它与p3所指向的 "123456 "优化成一块。
}

还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。栈的空间大小有限，vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须要知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的，不用我们担心。堆是动态分配内存的，并且可以分配使用很大的内存空间。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片（有点类似于磁盘碎片），因为C分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片。在栈上存取数据要比通过指针在堆上存取数据快些。
栈是先入后出的，一般由高地址向低地址生长。而堆是由低地址到高地址生长。
堆（heap）和栈（stack）是C/C++编程中不可避免会碰到的两个基本概念。在具体的C/C++编程框架中，这两个概念并不是并行的。对底层机器代码的研究可以揭示，栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。具体地说，现代计算机（串行执行机制），都直接在代码底层支持栈的数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。这种机制的特点是效率高，但支持的数据类型有限，一般是整数、指针、浮点数等系统直接支持的数据类型，并不直接支持其它数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。及其的call指令里隐含了把返回地址入栈，然后调转至子程序地址的操作，而子程序中的ret指令则隐含从栈中弹出返回地址并跳转的操作。C/C++中的自动变量是直接利用栈的例子，这也就是为什么当函数返回时，该函数的自动变量失效的原因。
与栈不同，堆的数据结构并不是由系统（无论是机器系统还是操作系统）支持的，而是由函数库提供的。基本的malloc/relloc/free函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回到内部堆结构中，可能会被适当的处理（比如和其他空闲空间合并成更大的空闲空间），以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池（Cache），使用这套机制有如下若干原因：

系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及倍数的内存请求（按页分配）；这样的话对于大量的小内存分类来说会造成浪费。
系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和内核态的转换。
没有管理的内存分配在大量复杂的内存分配释放操作下会造成内存碎片。

2.4.2 栈和堆对比

从以上知识可以得到：

栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；
堆是函数库提供的功能，特点是灵活方便，数据适用面广，但是效率有一定的降低。
栈是系统数据结构，对于进程和线程是唯一的；堆是函数库内部数据结构，不一定唯一。
不用堆分配的内存无法互相操作。
栈空间分静态分配和动态分配两种。静态分配是由编译器完成的，比如自动变量（auto）的分配。动态分配由alloca函数完成。栈的动态分配无需释放（是自动释放的），也就没有释放函数。为了程序的可移植性，栈的动态分配是不鼓励的！
堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放会系统，但是精确的申请内存/释放内存匹配是良好的程序的基本要素。

一般不是必要就不要动态创建，不允许动态创建的内存当局部变量用，用完马上释放掉的做法。

理由：

栈分配比堆快，只需要一条指令就能分配所有的局部变量。
栈不会出现内存碎片。
栈对象自动释放，更方便管理。

当然，某些情况下该申请堆区空间的时候就要申请，不要躲避。比如：

对象足够大。
对象需要在某个特定的时刻进行构造或者析构。
类只允许对象动态创建，比如VCL的大多数类。

栈内存和堆内存各有什么作用？

栈：先进后出
堆：顺序随意

栈和堆申请空间后的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲节点链表中删除，并将该结点的的空间分配给程序。另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

栈和堆申请大小的限制

栈：在Windows/单片机下，栈是向低地址扩展的数据结构，是一块连续的内存区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在Windows下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。 Linux的话，堆和栈差不多空间
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。栈的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

栈和堆申请效率的比较

栈由系统自动分配释放，效率较快。但程序员无法控制。
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便。另外，在Windows下，最好使用Virtual Alloc分配内存，它不是在堆区，也不是在栈区分配内存，而是直接在进程的地址空间中保留一块内存，虽然用起来最不方便，但是速度快，也最灵活。

栈和堆中存储的内容

栈：在函数调用时，第一个进栈的是函数调用语句的下一条可执行语句的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数的下一条指令（函数调用语句的下一条可执行语句的地址），程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。