从汇编代码学习C++语言1—类对象构造函数与析构函数

从汇编代码学习C++语言1—类对象构造函数与析构函数

        类对象必须经历初始化与销毁两个过程，类的构造函数与析构函数担当此重任。本文作为从汇编代码学习C++语言系列的第一篇，来分析类对象如何构造与销毁。

        示例代码1：

class Object
{
public:
	int code1;
	int code2;
};

int main(int argc, char *argv[])
{
	int i = 0;
	Object c;
	//func(1, c, 2);
	return 0;
}

         示例代码1没有实现构造函数与析构函数，汇编代码如下：

Disassembly of section .text:

00000000 <_main>:
   0:	55                   	push   %ebp    
   1:	89 e5                	mov    %esp,%ebp
   3:	83 e4 f0             	and    $0xfffffff0,%esp  //Memory Alignment
   6:	83 ec 10             	sub    $0x10,%esp        //Assign stack Memory, 16Bytes
   9:	e8 00 00 00 00       	call   e <_main+0xe>     
   e:	c7 44 24 0c 00 00 00 	movl   $0x0,0xc(%esp)    //Assign 0 to Memory Address(esp + 12Bytes)
  15:	00 
  16:	b8 00 00 00 00       	mov    $0x0,%eax         //Summary: code1 and code2 is not assigned value.
  1b:	c9                   	leave  
  1c:	c3                   	ret    
  1d:	90                   	nop
  1e:	90                   	nop
  1f:	90                   	nop

           示例代码2：

class Object
{
public:
        Object(){}
	~Object(){}
	int code1;
	int code2;
};

int main(int argc, char *argv[])
{
	int i = 0;
	Object c;
	//func(1, c, 2);
	return 0;
}

             示例代码2实现构造函数与析构函数，汇编代码如下：
        

Disassembly of section .text:

00000000 <_main>:
   0:	55                   	push   %ebp
   1:	89 e5                	mov    %esp,%ebp
   3:	53                   	push   %ebx
   4:	83 e4 f0             	and    $0xfffffff0,%esp
   7:	83 ec 20             	sub    $0x20,%esp         //Assign Stack Memory,32Bytes
   a:	e8 00 00 00 00       	call   f <_main+0xf>           
   f:	c7 44 24 1c 00 00 00 	movl   $0x0,0x1c(%esp)    //Assign Zero to Memory Address(esp + 28Bytes)
  16:	00 
  17:	8d 44 24 14          	lea    0x14(%esp),%eax    //Assign Memory Address(esp + 20Bytes) to eax
  1b:	89 04 24             	mov    %eax,(%esp)        //Assign eax to esp, so now esp will point to esp + 20Bytes
  1e:	e8 00 00 00 00       	call   23 <_main+0x23>    //Call Object constructor function (ObjectC1Ev)
  23:	bb 00 00 00 00       	mov    $0x0,%ebx          
  28:	8d 44 24 14          	lea    0x14(%esp),%eax    //Assign Memory Address(esp + 20Bytes) to eax

  2c:	89 04 24             	mov    %eax,(%esp)        //Move eax to esp
  2f:	e8 00 00 00 00       	call   34 <_main+0x34>    //Call Object destructor function (ObjectD1Ev)
  34:	89 d8                	mov    %ebx,%eax          
  36:	8b 5d fc             	mov    -0x4(%ebp),%ebx    //
  39:	c9                   	leave  
  3a:	c3                   	ret    
  3b:	90                   	nop

Disassembly of section .text$_ZN6ObjectC1Ev:

00000000 <__ZN6ObjectC1Ev>:                                //do nothing, just do stack balance
   0:	55                   	push   %ebp
   1:	89 e5                	mov    %esp,%ebp
   3:	5d                   	pop    %ebp
   4:	c3                   	ret    
   5:	90                   	nop
   6:	90                   	nop
   7:	90                   	nop

Disassembly of section .text$_ZN6ObjectD1Ev:

00000000 <__ZN6ObjectD1Ev>:                               //do nothing, just do stack balance
   0:	55                   	push   %ebp
   1:	89 e5                	mov    %esp,%ebp
   3:	5d                   	pop    %ebp
   4:	c3                   	ret    
   5:	90                   	nop
   6:	90                   	nop
   7:	90                   	nop

           Sample Code 3, let constructor and destructor do something:

class Object
{
public:
    Object()
	{
		code1 = 10;
		code2 = 5;
	}
	~Object()
	{
		code1 = 0;
		code2 = 0;
	}
	int code1;
	int code2;
};

int main(int argc, char *argv[])
{
	int i = 0;
	Object c;
	//func(1, c, 2);
	return 0;
}

               And assembly codes list following:

              

Disassembly of section .text:

00000000 <_main>:
   0:	55                   	push   %ebp
   1:	89 e5                	mov    %esp,%ebp
   3:	53                   	push   %ebx
   4:	83 e4 f0             	and    $0xfffffff0,%esp   // see above
   7:	83 ec 20             	sub    $0x20,%esp
   a:	e8 00 00 00 00       	call   f <_main+0xf>
   f:	c7 44 24 1c 00 00 00 	movl   $0x0,0x1c(%esp)
  16:	00 
  17:	8d 44 24 14          	lea    0x14(%esp),%eax
  1b:	89 04 24             	mov    %eax,(%esp)
  1e:	e8 00 00 00 00       	call   23 <_main+0x23>
  23:	bb 00 00 00 00       	mov    $0x0,%ebx
  28:	8d 44 24 14          	lea    0x14(%esp),%eax
  2c:	89 04 24             	mov    %eax,(%esp)
  2f:	e8 00 00 00 00       	call   34 <_main+0x34>
  34:	89 d8                	mov    %ebx,%eax
  36:	8b 5d fc             	mov    -0x4(%ebp),%ebx
  39:	c9                   	leave  
  3a:	c3                   	ret    
  3b:	90                   	nop

Disassembly of section .text$_ZN6ObjectC1Ev:

00000000 <__ZN6ObjectC1Ev>:
   0:	55                   	push   %ebp
   1:	89 e5                	mov    %esp,%ebp
   3:	8b 45 08             	mov    0x8(%ebp),%eax     //
   6:	c7 00 0a 00 00 00    	movl   $0xa,(%eax)        //Assign 10 to ebp + 8
   c:	8b 45 08             	mov    0x8(%ebp),%eax      
   f:	c7 40 04 0a 00 00 00 	movl   $0x5,0x4(%eax)     //Assign 5 to (ebp + 8) + 4, 

                                                          //note stack memory assigns from high to low.

                                                          //So ebp+8 is address of Object c.
  16:	5d                   	pop    %ebp
  17:	c3                   	ret    

Disassembly of section .text$_ZN6ObjectD1Ev:

00000000 <__ZN6ObjectD1Ev>:
   0:	55                   	push   %ebp
   1:	89 e5                	mov    %esp,%ebp
   3:	8b 45 08             	mov    0x8(%ebp),%eax
   6:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   c:	8b 45 08             	mov    0x8(%ebp),%eax
   f:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
  16:	5d                   	pop    %ebp
  17:	c3                   	ret