程序员经验分享-hwhale

堆栈的工作原理

2023-05-16

声明：以下均为个人收集的一些资料，非原创


每一个使用c语言的都应该知道栈的重要性，我们能够使用C/C++语言写出诸多复杂的程序，很大功劳一部分有归于栈的实现，因为它可以帮助我们实现函数间的嵌套调用。

汇编程序的运行是不需要栈的，所以注定它函数的嵌套层数不会太多，一般是父函数调用子函数，然后在子函数就返回了，很少见到子函数还会调用孙子函数的情况。这是由它的语言特性决定的。因为每当汇编语言调用子函数时，就会将返回的PC地址保存在LR中， 如果子函数还要调用孙子函数，那么执行时也会将子函数的返回地址保存在LR中，这时如果要返回父函数，就需要将返回父PC的地址保存在另外一个寄存器中，比如R0中，这将占用另外一个寄存器。

cpu的寄存器资源是很有限的，如果一个程序相对复杂，函数间有4、5层的嵌套调用，那将会占用至少4、5个寄存器资源，这是不现实的，也一般不会这样做，而且对于一种与硬件联系紧密的汇编语言来说，太复杂的逻辑关系或嵌套关系也不好实现。

汇编语言是底层语言，它没有栈，它也不需要编写很复杂很庞大的程序，即使没有内存（SDRAM），它也能在cpu的片内内存运行以完成一些裸机硬件程序；但是C语言是高级语言，它能够编写复杂庞大的程序，所以它需要函数间的多层调用，它需要用到指针的灵活赋值等等，但是这些都有依赖于栈， 那么栈是怎么让C语言能够变得如此强大呢?


一、栈的基本了解

每次我们开机的时候，系统都会初始化好栈指针（SP），初始方法也很简单，在boot_load代码里我们可以看到：ldr sp, =4096   这样的语句，实际就是让SP指针指向这样的地址，但是注意，这个地址是内存中的地址，而不是cpu片内地址，内存资源相对cpu资源来说充裕多了，所以SP可以有很大的增长空间，这也是C语言可以写复杂程序的前提。

我们知道栈在不同的系统中的增长方向是不一样的，但是栈的结构决定了它是一个先进后出的模型，所以和我们函数调用的过程是类似的，最先调用的函数总是最后返回，而最后调用的函数则是最最先返回，也就后调用先返回。

栈的出栈方式决定函数的返回过程，栈的增长空间支持函数嵌套的复杂程度。


二、栈的基本原理

下面是收集的基于ARM平台的一个例子

C语言进行函数调用的时候，常常会传递给被调用的函数一些参数，对于这些C语言级别的参数，被编译器翻译成汇编语言的时候，
就要找个地方存放一下，并且让被调用的函数能够访问，否则就没发实现传递参数了。对于找个地方放一下，分两种情况。
    一种情况是，本身传递的参数就很少，就可以通过寄存器传送参数,因为在前面的保存现场的动作中，已经保存好了对应的寄存器的值，那么此时，这些寄存器就是空闲的，可以供我们使用的了,那就可以放参数，而参数少的情况下，就足够存放参数了，比如参数有2个，那么就用r0和r1存放即可。（关于参数1和参数2，具体哪个放在r0，哪个放在r1，就是和APCS中的“在函数调用之间传递/返回参数”相关了,APCS中会有详细的约定。感兴趣的自己去研究）
    

但是如果参数太多，寄存器不够用，那么就得把多余的参数堆栈中了,即可以用堆栈来传递所有的或寄存器放不下的那些多余的参数。


举例分析C语言函数调用是如何使用堆栈的
    对于上面的解释的堆栈的作用显得有些抽象，此处再用例子来简单说明一下，就容易明白了：
    用:
        arm-inux-objdump –d u-boot > dump_u-boot.txt
    
    可以得到dump_u-boot.txt文件。该文件就是中，包含了u-boot中的程序的可执行的汇编代码，
    其中我们可以看到C语言的函数的源代码，到底对应着那些汇编代码。
    
    下面贴出两个函数的汇编代码，
    一个是clock_init，
    另一个是与clock_init在同一C源文件中的，另外一个函数CopyCode2Ram：
    
        33d0091c <CopyCode2Ram>:
        33d0091c:  e92d4070   push   {r4, r5, r6, lr}
        33d00920:  e1a06000   mov r6, r0
        33d00924:  e1a05001   mov r5, r1
        33d00928:  e1a04002   mov r4, r2
        33d0092c:  ebffffef   bl  33d008f0 <bBootFrmNORFlash>
        ... ...
        33d00984:  ebffff14   bl  33d005dc <nand_read_ll>
        ... ...
        33d009a8:  e3a00000   mov r0, #0 ; 0x0
        33d009ac:  e8bd8070   pop {r4, r5, r6, pc}


        33d009b0 <clock_init>:
        33d009b0:  e3a02313   mov r2, #1275068416   ; 0x4c000000
        33d009b4:  e3a03005   mov r3, #5 ; 0x5
        33d009b8:  e5823014   str r3, [r2, #20]
        ... ...
        33d009f8:  e1a0f00e   mov pc, lr
    
    
    （1）clock_init部分的代码
        可以看到该函数第一行：
            33d009b0:  e3a02313   mov r2, #1275068416   ; 0x4c000000
        就没有我们所期望的push指令，没有去将一些寄存器的值放到堆栈中。这是因为，我们clock_init这部分的内容，
        所用到的r2,r3等等寄存器，和前面调用clock_init之前所用到的寄存器r0，没有冲突，所以此处可以不用push去保存这类寄存器的值，
        不过有个寄存器要注意，那就是r14，即lr，其是在前面调用clock_init的时候，用的是bl指令，所以会自动把跳转时候的pc的值赋值给lr，
        所以也不需要push指令去将PC的值保存到堆栈中。
        而clock_init的代码的最后一行:
            33d009f8: e1a0f00e mov pc, lr
        
        就是我们常见的mov pc, lr，把lr的值，即之前保存的函数调用时候的PC值，赋值给现在的PC，
        这样就实现了函数的正确的返回，即返回到了函数调用时候下一个指令的位置。
        这样CPU就可以继续执行原先函数内剩下那部分的代码了。
    
    （2）CopyCode2Ram部分的代码
        其第一行：
            33d0091c: e92d4070 push {r4, r5, r6, lr}
        
        就是我们所期望的，用push指令，保存了r4,r5,r以及lr。
        用push去保存r4,r5,r6，那是因为所谓的保存现场，以后后续函数返回时候再恢复现场，
        
        而用push去保存lr，那是因为此函数里面，还有其他函数调用：
        
            33d0092c:  ebffffef   bl  33d008f0 <bBootFrmNORFlash>
            ... ...
            33d00984:  ebffff14   bl  33d005dc <nand_read_ll>
            ... ...
        
        也用到了bl指令，会改变我们最开始进入clock_init时候的lr的值，所以我们要用push也暂时保存起来。
        而对应地，CopyCode2Ram的最后一行：
            33d009ac: e8bd8070 pop {r4, r5, r6, pc}
        就是把之前push的值，给pop出来，还给对应的寄存器，其中最后一个是将开始push的lr的值，pop出来给赋给PC，因为实现了函数的返回。
        另外，我们注意到，在CopyCode2Ram的倒数第二行是：
            33d009a8: e3a00000 mov r0, #0 ; 0x0
        
        
        是把0赋值给r0寄存器，这个就是我们所谓返回值的传递，是通过r0寄存器的。
        此处的返回值是0，也对应着C语言的源码中的“return 0”.
        
        
    对于使用哪个寄存器来传递返回值：
    当然你也可以用其他暂时空闲没有用到的寄存器来传递返回值，但是这些处理方式，本身是根据ARM的APCS的寄存器的使用的约定而设计的，
    最好不要随便改变使用方式，最好还是按照其约定的来处理，这样程序更加符合规范。



下面是收集的x86平台的一个例子（个人觉得讲的很好）

    1）本文讨论的编译环境是 Visual C/C++，由于高级语言的堆栈工作机制大致相同，因此对其他编译环境或高级语言如C#也有意义。

    2）本文讨论的堆栈，是指程序为每个线程分配的默认堆栈，用以支持程序的运行，而不是指程序员为了实现算法而自己定义的堆栈。

    3)  本文讨论的平台为intel x86。

    4）本文的主要部分将尽量避免涉及到汇编的知识，在本文最后可选章节，给出前面章节的反编译代码和注释。

    5）结构化异常处理也是通过堆栈来实现的(当你使用try…catch语句时，使用的就是c++对windows结构化异常处理的扩展)，但是关于结构化异常处理的主题太复杂了，本文将不会涉及到。

document_thumb_thumb[4]从一些基本的知识和概念开始

    1) 程序的堆栈是由处理器直接支持的。在intel x86的系统中，堆栈在内存中是从高地址向低地址扩展（这和自定义的堆栈从低地址向高地址扩展不同），如下图所示：

image

    因此，栈顶地址是不断减小的，越后入栈的数据，所处的地址也就越低。

    2) 在32位系统中，堆栈每个数据单元的大小为4字节。小于等于4字节的数据，比如字节、字、双字和布尔型，在堆栈中都是占4个字节的；大于4字节的数据在堆栈中占4字节整数倍的空间。

    3) 和堆栈的操作相关的两个寄存器是EBP寄存器和ESP寄存器的，本文中，你只需要把EBP和ESP理解成2个指针就可以了。ESP寄存器总是指向堆栈的栈顶，执行PUSH命令向堆栈压入数据时，ESP减4，然后把数据拷贝到ESP指向的地址；执行POP命令时，首先把ESP指向的数据拷贝到内存地址/寄存器中，然后ESP加4。EBP寄存器是用于访问堆栈中的数据的，它指向堆栈中间的某个位置（具体位置后文会具体讲解），函数的参数地址比EBP的值高，而函数的局部变量地址比EBP的值低，因此参数或局部变量总是通过EBP加减一定的偏移地址来访问的，比如，要访问函数的第一个参数为EBP+8。

    4) 堆栈中到底存储了什么数据？ 包括了：函数的参数，函数的局部变量，寄存器的值（用以恢复寄存器），函数的返回地址以及用于结构化异常处理的数据（当函数中有try…catch语句时才有，本文不讨论）。这些数据是按照一定的顺序组织在一起的，我们称之为一个堆栈帧（Stack Frame）。一个堆栈帧对应一次函数的调用。在函数开始时，对应的堆栈帧已经完整地建立了（所有的局部变量在函数帧建立时就已经分配好空间了，而不是随着函数的执行而不断创建和销毁的）；在函数退出时，整个函数帧将被销毁。

    5) 在文中，我们把函数的调用者称为caller（调用者），被调用的函数称为callee（被调用者）。之所以引入这个概念，是因为一个函数帧的建立和清理，有些工作是由Caller完成的，有些则是由Callee完成的。

document_thumb_thumb4开始讨论堆栈是如何工作的

    我们来讨论堆栈的工作机制。堆栈是用来支持函数的调用和执行的，因此，我们下面将通过一组函数调用的例子来讲解，看下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int foo1( int m, int n)
{
     int p=m*n;
     return p;
}
int foo( int a, int b)
{
     int c=a+1;
     int d=b+1;
     int e=foo1(c,d);
     return e;
}
 
int main()
{
     int result=foo(3,4);
     return 0;
}

    这段代码本身并没有实际的意义，我们只是用它来跟踪堆栈。下面的章节我们来跟踪堆栈的建立，堆栈的使用和堆栈的销毁。

document_thumb_thumb4堆栈的建立

    我们从main函数执行的第一行代码，即int result=foo(3,4); 开始跟踪。这时main以及之前的函数对应的堆栈帧已经存在在堆栈中了，如下图所示：

image

图1

    参数入栈 

   当foo函数被调用，首先，caller（此时caller为main函数）把foo函数的两个参数：a=3,b=4压入堆栈。参数入栈的顺序是由函数的调用约定(Calling Convention)决定的，我们将在后面一个专门的章节来讲解调用约定。一般来说，参数都是从右往左入栈的，因此，b=4先压入堆栈，a=3后压入，如图：

image

图2

   返回地址入栈

    我们知道，当函数结束时，代码要返回到上一层函数继续执行，那么，函数如何知道该返回到哪个函数的什么位置执行呢？函数被调用时，会自动把下一条指令的地址压入堆栈，函数结束时，从堆栈读取这个地址，就可以跳转到该指令执行了。如果当前＂call foo＂指令的地址是0x00171482,由于call指令占5个字节，那么下一个指令的地址为0x00171487，0x00171487将被压入堆栈:

image

图3

    代码跳转到被调用函数执行

    返回地址入栈后，代码跳转到被调用函数foo中执行。到目前为止，堆栈帧的前一部分，是由caller构建的；而在此之后，堆栈帧的其他部分是由callee来构建。

   EBP指针入栈

    在foo函数中，首先将EBP寄存器的值压入堆栈。因为此时EBP寄存器的值还是用于main函数的，用来访问main函数的参数和局部变量的，因此需要将它暂存在堆栈中，在foo函数退出时恢复。同时，给EBP赋于新值。

    1）将EBP压入堆栈

    2）把ESP的值赋给EBP

image

图4

    这样一来，我们很容易发现当前EBP寄存器指向的堆栈地址就是EBP先前值的地址，你还会发现发现，EBP+4的地址就是函数返回值的地址，EBP+8就是函数的第一个参数的地址（第一个参数地址并不一定是EBP+8，后文中将讲到）。因此，通过EBP很容易查找函数是被谁调用的或者访问函数的参数（或局部变量）。

    为局部变量分配地址

    接着，foo函数将为局部变量分配地址。程序并不是将局部变量一个个压入堆栈的，而是将ESP减去某个值，直接为所有的局部变量分配空间，比如在foo函数中有ESP=ESP-0x00E4，（根据烛秋兄在其他编译环境上的测试，也可能使用push命令分配地址，本质上并没有差别，特此说明）如图所示：

image

图5

     奇怪的是，在debug模式下，编译器为局部变量分配的空间远远大于实际所需，而且局部变量之间的地址不是连续的（据我观察，总是间隔8个字节）如下图所示：

  image

图6

    我还不知道编译器为什么这么设计，或许是为了在堆栈中插入调试数据，不过这无碍我们今天的讨论。

通用寄存器入栈

     最后，将函数中使用到的通用寄存器入栈，暂存起来，以便函数结束时恢复。在foo函数中用到的通用寄存器是EBX，ESI，EDI，将它们压入堆栈，如图所示：

image

图7

   至此，一个完整的堆栈帧建立起来了。

document_thumb_thumb4 堆栈特性分析

   上一节中，一个完整的堆栈帧已经建立起来，现在函数可以开始正式执行代码了。本节我们对堆栈的特性进行分析，有助于了解函数与堆栈帧的依赖关系。

   1）一个完整的堆栈帧建立起来后，在函数执行的整个生命周期中，它的结构和大小都是保持不变的；不论函数在什么时候被谁调用，它对应的堆栈帧的结构也是一定的。

   2）在A函数中调用B函数，对应的，是在A函数对应的堆栈帧“下方”建立B函数的堆栈帧。例如在foo函数中调用foo1函数，foo1函数的堆栈帧将在foo函数的堆栈帧下方建立。如下图所示：

image

图8 

  3）函数用EBP寄存器来访问参数和局部变量。我们知道，参数的地址总是比EBP的值高，而局部变量的地址总是比EBP的值低。而在特定的堆栈帧中，每个参数或局部变量相对于EBP的地址偏移总是固定的。因此函数对参数和局部变量的的访问是通过EBP加上某个偏移量来访问的。比如，在foo函数中，EBP+8为第一个参数的地址，EBP-8为第一个局部变量的地址。

   4）如果仔细思考，我们很容易发现EBP寄存器还有一个非常重要的特性，请看下图中：

image

图9

   我们发现，EBP寄存器总是指向先前的EBP，而先前的EBP又指向先前的先前的EBP，这样就在堆栈中形成了一个链表！这个特性有什么用呢，我们知道EBP+4地址存储了函数的返回地址，通过该地址我们可以知道当前函数的上一级函数（通过在符号文件中查找距该函数返回地址最近的函数地址，该函数即当前函数的上一级函数），以此类推，我们就可以知道当前线程整个的函数调用顺序。事实上，调试器正是这么做的，这也就是为什么调试时我们查看函数调用顺序时总是说“查看堆栈”了。

document_thumb_thumb4返回值是如何传递的

    堆栈帧建立起后，函数的代码真正地开始执行，它会操作堆栈中的参数，操作堆栈中的局部变量，甚至在堆（Heap）上创建对象，balabala….，终于函数完成了它的工作，有些函数需要将结果返回给它的上一层函数，这是怎么做的呢？

    首先，caller和callee在这个问题上要有一个“约定”，由于caller是不知道callee内部是如何执行的，因此caller需要从callee的函数声明就可以知道应该从什么地方取得返回值。同样的，callee不能随便把返回值放在某个寄存器或者内存中而指望Caller能够正确地获得的，它应该根据函数的声明，按照“约定”把返回值放在正确的”地方“。下面我们来讲解这个“约定”： 
    1）首先，如果返回值等于4字节，函数将把返回值赋予EAX寄存器，通过EAX寄存器返回。例如返回值是字节、字、双字、布尔型、指针等类型，都通过EAX寄存器返回。

    2）如果返回值等于8字节，函数将把返回值赋予EAX和EDX寄存器，通过EAX和EDX寄存器返回，EDX存储高位4字节，EAX存储低位4字节。例如返回值类型为__int64或者8字节的结构体通过EAX和EDX返回。

    3)  如果返回值为double或float型，函数将把返回值赋予浮点寄存器，通过浮点寄存器返回。

    4）如果返回值是一个大于8字节的数据，将如何传递返回值呢？这是一个比较麻烦的问题，我们将详细讲解：

        我们修改foo函数的定义如下并将它的代码做适当的修改：

1
2
3
4
MyStruct foo( int a, int b)
{
...
}
         MyStruct定义为：
1
2
3
4
5
6
struct MyStruct
{
     int value1;
     __int64 value2;
     bool value3;
};

     这时，在调用foo函数时参数的入栈过程会有所不同，如下图所示：

image

图10

    caller会在压入最左边的参数后，再压入一个指针，我们姑且叫它ReturnValuePointer，ReturnValuePointer指向caller局部变量区的一块未命名的地址，这块地址将用来存储callee的返回值。函数返回时，callee把返回值拷贝到ReturnValuePointer指向的地址中，然后把ReturnValuePointer的地址赋予EAX寄存器。函数返回后，caller通过EAX寄存器找到ReturnValuePointer，然后通过ReturnValuePointer找到返回值，最后，caller把返回值拷贝到负责接收的局部变量上（如果接收返回值的话）。

    你或许会有这样的疑问，函数返回后，对应的堆栈帧已经被销毁，而ReturnValuePointer是在该堆栈帧中，不也应该被销毁了吗？对的，堆栈帧是被销毁了，但是程序不会自动清理其中的值，因此ReturnValuePointer中的值还是有效的。

document_thumb_thumb4堆栈帧的销毁

    当函数将返回值赋予某些寄存器或者拷贝到堆栈的某个地方后，函数开始清理堆栈帧，准备退出。堆栈帧的清理顺序和堆栈建立的顺序刚好相反：（堆栈帧的销毁过程就不一一画图说明了）

   1）如果有对象存储在堆栈帧中，对象的析构函数会被函数调用。

    2）从堆栈中弹出先前的通用寄存器的值，恢复通用寄存器。

    3）ESP加上某个值，回收局部变量的地址空间（加上的值和堆栈帧建立时分配给局部变量的地址大小相同）。

    4）从堆栈中弹出先前的EBP寄存器的值，恢复EBP寄存器。

    5）从堆栈中弹出函数的返回地址，准备跳转到函数的返回地址处继续执行。

    6）ESP加上某个值，回收所有的参数地址。

    前面1-5条都是由callee完成的。而第6条，参数地址的回收，是由caller或者callee完成是由函数使用的调用约定（calling convention ）来决定的。下面的小节我们就来讲解函数的调用约定。

document_thumb_thumb4函数的调用约定（calling convention）

    函数的调用约定(calling convention)指的是进入函数时，函数的参数是以什么顺序压入堆栈的，函数退出时，又是由谁（Caller还是Callee）来清理堆栈中的参数。有2个办法可以指定函数使用的调用约定：

    1）在函数定义时加上修饰符来指定，如

1
2
3
4
void __thiscall mymethod();
{
     ...
}
    2）在VS工程设置中为工程中定义的所有的函数指定默认的调用约定：在工程的主菜单打开Project|Project Property|Configuration Properties|C/C++|Advanced|Calling Convention，选择调用约定（注意：这种做法对类成员函数无效）。

    常用的调用约定有以下3种：

    1）__cdecl。这是VC编译器默认的调用约定。其规则是：参数从右向左压入堆栈，函数退出时由caller清理堆栈中的参数。这种调用约定的特点是支持可变数量的参数，比如printf方法。由于callee不知道caller到底将多少参数压入堆栈，因此callee就没有办法自己清理堆栈，所以只有函数退出之后，由caller清理堆栈，因为caller总是知道自己传入了多少参数。

    2）__stdcall。所有的Windows API都使用__stdcall。其规则是：参数从右向左压入堆栈，函数退出时由callee自己清理堆栈中的参数。由于参数是由callee自己清理的，所以__stdcall不支持可变数量的参数。

    3) __thiscall。类成员函数默认使用的调用约定。其规则是：参数从右向左压入堆栈，x86构架下this指针通过ECX寄存器传递，函数退出时由callee清理堆栈中的参数，x86构架下this指针通过ECX寄存器传递。同样不支持可变数量的参数。如果显式地把类成员函数声明为使用__cdecl或者__stdcall，那么，将采用__cdecl或者__stdcall的规则来压栈和出栈，而this指针将作为函数的第一个参数最后压入堆栈，而不是使用ECX寄存器来传递了。

document_thumb_thumb4反编译代码的跟踪（不熟悉汇编可跳过）

    以下代码为和foo函数对应的堆栈帧建立相关的代码的反编译代码，我将逐行给出注释，可对照前文中对堆栈的描述：

    main函数中 int result=foo(3,4); 的反汇编：

1
2
3
4
5
008A147E  push        4                     //b=4 压入堆栈  
008A1480  push        3                     //a=3 压入堆栈,到达图2的状态
008A1482  call        foo (8A10F5h)         //函数返回值入栈,转入foo中执行,到达图3的状态
008A1487  add         esp,8                 //foo返回,由于采用__cdecl,由Caller清理参数
008A148A  mov         dword ptr [result],eax //返回值保存在EAX中,把EAX赋予result变量

    下面是foo函数代码正式执行前和执行后的反汇编代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
008A13F0  push        ebp                  //把ebp压入堆栈
008A13F1  mov         ebp,esp              //ebp指向先前的ebp,到达图4的状态
008A13F3  sub         esp,0E4h             //为局部变量分配0E4字节的空间,到达图5的状态
008A13F9  push        ebx                  //压入EBX
008A13FA  push        esi                  //压入ESI
008A13FB  push        edi                  //压入EDI,到达图7的状态
008A13FC  lea         edi,[ebp-0E4h]       //以下4行把局部变量区初始化为每个字节都等于cch
008A1402  mov         ecx,39h
008A1407  mov         eax,0CCCCCCCCh
008A140C  rep stos    dword ptr es:[edi]
......                                      //省略代码执行N行
......
008A1436  pop         edi                   //恢复EDI 
008A1437  pop         esi                   //恢复ESI
008A1438  pop         ebx                   //恢复EBX
008A1439  add         esp,0E4h              //回收局部变量地址空间
008A143F  cmp         ebp,esp               //以下3行为Runtime Checking,检查ESP和EBP是否一致  
008A1441  call        @ILT+330(__RTC_CheckEsp) (8A114Fh)
008A1446  mov         esp,ebp
008A1448  pop         ebp                   //恢复EBP
008A1449  ret                               //弹出函数返回地址，跳转到函数返回地址执行                                            //(__cdecl调用约定,Callee未清理参数)

document_thumb_thumb4[1]参考

Debug Tutorial Part 2: The Stack

Intel汇编语言程序设计(第四版) 第8章

http://msdn.microsoft.com/zh-cn/library/46t77ak2(VS.80).aspx

http://www.360doc.com/content/10/1126/23/3267996_72551321.shtml
http://www.cnblogs.com/dwlsxj/p/Stack.html
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

堆栈的工作原理 的相关文章

  • 关于SubSonic3.0生成的表名自动加复数（s）的“用户代码未处理SqlException，对象名‘xxxs‘无效”异常处理

    关于SubSonic3 0生成的表名自动加复数 xff08 s xff09 的 用户代码未处理SqlException xff0c 对象名 39 xxxs 39 无效 异常处理 参考文章 xff1a xff08 1 xff09 关于SubS

  • 互联网金融风控面试算法知识(三)

    资料来源于网络搜集和汇总 xff0c 把算法知识的总结放在业务知识后面也是为了说明实际工作业务落地应用的重要性大于算法创新 面试题依然是适用于3年经验以内的初学者 xff0c 希望大家在学习算法的同时不要一心只研究算法而脱离了业务 xff0

  • wiki树莓派安装ubuntu mate 和 ros

    两大步骤 1 安装ubuntu mate 2 安装ros 一 安装ubuntu mate 下载ubuntu mate 18 04 img 并制作系统盘 首先要说的就是树莓派支持的系统是很多样的 xff0c 但是针对ros xff0c 我们只

  • npm 的工作原理

    包 Package 和模块 Module 如何定义一个Package 满足如下条件都可以称为一个包 xff1a 一个文件夹包含应用程序 xff0c 使用package json来描述它 a 一个用gzip压缩的文件夹 xff0c 满足 a

  • 2023最全Postman安装使用详解

    一 Postman背景介绍 用户在开发或者调试网络程序或者是网页B S模式的程序的时候是需要一些方法来跟踪网页请求的 xff0c 用户可以使用一些网络的监视工具比如著名的Firebug等网页调试工具 今天给大家介绍的这款网页调试工具不仅可以

  • cmake 设置 debug release模式

    1 通过命令行的方式 cmake DCMAKE BUILD TYPE 61 Debug 2 set CMAKE BUILD TYPE Debug CACHE STRING 34 set build type to debug 34 或者 s

  • 华为笔试题（4）

    一 计算n x m的棋盘格子 xff08 n为横向的格子数 xff0c m为竖向的格子数 xff09 沿着各自边缘线从左上角走到右下角 xff0c 总共有多少种走法 xff0c 要求不能走回头路 xff0c 即 xff1a 只能往右和往下走

  • 安装RedisBloom插件

    前言 安装RedisBloom模块会遇到很多坑 xff0c 希望你不要和我一样踩的这么全 x1f60f 如果觉得编译麻烦 xff0c 我也上传了我编译的so文件 xff0c 可以直接加载使用 https download csdn net

  • ROS Catkin 教程之 CMakeLists.txt

    1 概览 CMakeLists txt 是用 CMake 构建系统构建 ROS 程序包的输入文件 任何兼容 CMake 的包都包含一个或多个 CMakeLists txt 文件 xff0c 用以描述怎样构建和安装代码 catkin 项目采用

  • Xsens Mti-g-710 IMU driver在Ubuntu18.04 ROS melodic中的安装使用

    Ubuntu18 04下安装的ROS melodic 如何使用Xsens Mti g 710 IMU driver xff1f 这里给出一个详细步骤说明 这里的IMU是USB接口 1安装 首先插入IMU的USB口 命令行运行 gt lsus

  • PYTHON -MYSQLDB安装遇到的问题和解决办法

    PYTHON MYSQLDB安装遇到的问题和解决办法 参考文章 xff1a xff08 1 xff09 PYTHON MYSQLDB安装遇到的问题和解决办法 xff08 2 xff09 https www cnblogs com gaosh

  • 位姿估计Robot_pose_efk的配置和使用

    Robot pose efk 用于融合里程计 xff0c 惯性测量单元和视觉里程计的传感器输出 xff0c 从而减少测量中的总体误差 了解ROS的robot pose ekf软件包中扩展卡尔曼滤波器的用法 xff1a robot pose

  • linux录屏和截图软件

    linux下的录屏和截图软件有很多 xff0c kazam集成了录屏和截图两个功能 xff0c 而且十分轻量级 xff0c 比较好用 如果是在VirtualBox虚拟机中跑linux的话 xff0c virtualbox本身就提供录屏和截图

  • APM 学习 6 --- ArduPilot 线程

    ArduPilot 学习之路 6 xff0c 线程 英文原文地址 xff1a https ardupilot org dev docs learning ardupilot threading html 理解 ArduPilot 线程 线程

  • nginx 配置多个vue，环境部署

    1 最近项目要上线 xff0c 需要通过nginx作为代理 xff0c 要发布2个VUE前端项目 xff0c 记录一下nginx conf配置文件 亲自验证 xff0c 特此记录一下 xff0c 希望能帮助向我一样 小白的人 user ro

  • freertos源码分析（1）--初始篇

    代码下载地址 xff1a https www freertos org 部分转载参考 FreeRTOS基础知识 xff1a RTOS全称为 xff1a Real Time OS xff0c 就是实时操作系统 xff0c 强调的是 xff1a

  • nginx服务占用百分之百

    一 当nginx达到100 时 xff0c 也就是服务器负载突然上升 1 利用top命令查看cpu使用率较高的php cgi进程 PID USER PR NI VIRT RES SHR S CPU MEM TIME 43 COMMAND 1

  • Gazebo教程（使用roslaunch 启动Gazebo，world以及urdf模型）

    Gazebo教程 xff08 使用roslaunch 启动Gazebo xff0c world以及urdf模型 xff09 关于如何学习ROS可以参考古月居的这篇文章 1 https www zhihu com question 35788

  • dispatch_queue_create---创建队列

    dispatch queue create span class hljs keyword const span span class hljs keyword char span label dispatch queue attr t a

  • Java多种方式解决生产者消费者问题（十分详细）

    一 问题描述 生产者消费者问题 xff08 Producer consumer problem xff09 xff0c 也称有限缓冲问题 xff08 Bounded buffer problem xff09 xff0c 是一个多线程同步问题

随机推荐

  • Http协议WWW-Authenticate

    HTTP协议有一个叫WWW Authenticate的头字段 xff0c 可以用于实现登录验证 它是在RFC 2617中定义的 当服务器接收到一个request xff0c 并在实现下面的代码 xff1a br http response

  • Android 运行时注解

    编译时注解点击此处 xff5e xff5e xff5e 运行时注解 以 64 BindView 为例 下面是实现步骤 新建一个 apt annotation 的 java library xff0c 然后在库中新建一个注解 xff0c 传入

  • 使用k-近邻算法识别手写数字。

    在之前的文章中介绍了k 近邻算法的原理知识并且用Python实现了一个分类器 xff0c 而且完成了一个简单的优化约会网站配对效果的实例 在 机器学习实战 中有关kNN的后一部分内容就是一个手写识别系统 xff0c 可以识别手写的0 9的数

  • 在Ubuntu14.04不能添加PPA源到apt源的问题解决方法

    在Ubuntu14 04使用apt get 更新Git 时 xff0c 需要更新apt源 xff0c 添加一个带有最新Git的源 xff0c 如下命令 xff1a sudo add apt repository ppa git core p

  • 单片机的操作本质【以STM32系列为例】

    单片机的操作本质 摘要寄存器的本质单片机的操作本质操作寄存器的方法 摘要 本文档是笔者学习野火F103视频 课时5 至 课时7 的总结 视频链接 xff1a https study 163 com course introduction 1

  • 《视觉SLAM进阶：从零开始手写VIO》第一讲作业

    目录 1 视觉与IMU融合之后有何优势 xff1f 2 有哪些常见的视觉 43 IMU融合方案 xff1f 有没有工业界应用的例子 xff1f 3 在学术界 xff0c VIO研究有哪些新进展 xff1f 有没有将学习方法应用到VIO的例子

  • GPS坐标与UTM坐标的转换

    1 简介 1 1 消息 gps common定义了两个通用消息 xff0c 供GPS驱动程序输出 xff1a gps common GPSFix和gps common GPSStatus 在大多数情况下 xff0c 这些消息应同时发布 xf

  • NVIDIA Jetson TX2使用笔记（一）：开机设置

    0 写在前面 由于项目需要 xff0c 使用 NVIDIA Jetson TX2作为硬件开发平台 xff0c 在此记录使用方法和遇到的问题 NVIDIA Jetson TX2是英伟达的嵌入式开发套件 xff0c 可以进行视觉计算 xff0c

  • ORB-SLAM2的安装与运行

    0 背景简介 ORB SLAM是西班牙Zaragoza大学的Raul Mur Artal编写的视觉SLAM系统 他的论文 ORB SLAM a versatile andaccurate monocular SLAM system 34 发

  • Ubuntu14.04升级cmake版本的方法

    在Ubuntu14 04用以下命令默认安装的cmake版本为2 8 x xff0c 有时我们需要更高版本的cmake xff0c 所以需要升级 span class hljs built in sudo span apt get insta

  • 在TX2上配置ORB-SLAM2错误总结

    Pangolin 错误描述 usr lib gcc aarch64 linux gnu 5 aarch64 linux gnu libGL so undefined reference to 96 drmFreeDevice 解决方法 cd

  • docker镜像迁移/移植

    docker镜像迁移 移植 或者docker save 镜像名 版本号 o 路径 保存的包名 tar 通过这两个命令保存保存镜像 xff0c 下载到本地再上传到其他服务器 然后通过docker load lt 保存的包名 tar 完成镜像移

  • 安装并运行VINS-Mono

    0 A Robust and Versatile Monocular Visual Inertial State Estimator VINS Mono是单目视觉惯性系统的实时SLAM框架 它使用基于优化的滑动窗口配方来提供高精度的视觉惯性

  • 使用小觅双目-惯性相机运行VINS-Mono

    步骤 1 下载相机驱动MYNT EYE SDK 2 xff0c 然后make ros xff08 注意 xff1a 前面的Ubuntu安装也要操作 xff09 xff1b 2 安装VINS Mono xff1b 3 在MYNT EYE VI

  • 在TX2上安装VIINS-Mono——问题总结

    1 ceres solver 我们一般通过以下命令安装Eigen xff1a sudo apt get install libeigen3 dev 默认安装在 usr include eigen3 在CMakeList txt中一般用以下语

  • LeGO-LOAM初探：原理，安装和测试

    前言 最近要搞3D激光SLAM xff0c 先后测试了Autoware xff0c cartographer xff0c loam和LeGO LOAM 今天就带来LeGO LOAM的使用体验 Github xff1a https githu

  • IMU噪声标定——加速度计和陀螺仪的白噪声和零偏不稳定性

    前言 imu utils是一个用于分析IMU性能的ROS工具包 参考资料 Allan Variance Noise Analysis for Gyroscopesvectornav gyroscopeAn introduction to i

  • TF坐标变换

    文章目录 TF坐标变换TF功能包TF工具乌龟例程中的TF创建TF广播器创建TF监听器实现乌龟跟随运动 存在的问题总结参考 TF坐标变换 坐标变换是机器人学中一个非常基础 xff0c 同时也是非常重要的概念 机器人本体和机器人的工作环境中往往

  • Linux下目录文件的操作(opendir,readdir,closedir) 以及DIR，dirent,stat等结构体详解

    From http blog chinaunix net uid 27213819 id 3810699 html 注 xff1a 为什么要说 目录文件 xff1f 其实在linux中 目录也是一种 文件 xff0c 只是它的内容是上级的

  • 堆栈的工作原理

    声明 xff1a 以下均为个人收集的一些资料 xff0c 非原创 每一个使用c语言的都应该知道栈的重要性 xff0c 我们能够使用C C 43 43 语言写出诸多复杂的程序 xff0c 很大功劳一部分有归于栈的实现 xff0c 因为它可以帮

热门标签