EzDoum

찾기
처음으로 | 찾기 | 아카이브 | 글 올리기 | 링크 | 자료실 | 통계 | 연락처 | 자유게시판
이지도움 특집
전체보기
네트워크
TI OMAP35x
TI DaVinci
Analog Blackfin
RobotWar2005
임베디드!
캐쉬의 모든것
메모리 할당 알고리즘
CPU 파이프라이닝
자료구조(Tree)
금융

Login
이름

암호

기억하기


사용자 등록

현재 접속중인 등록 사용자는 0명, 익명 사용자는 2명 입니다.
전체 등록 사용자: 751명

마지막 답장
·libcurl + fuse 조합으로 되는게 많네. (1)
·Linux Ftrace에 관해 (3)
·Android MTP ( Media Transfer Protocol ) (1)
·Lighttpd에 인증을 digest 사용시 IE 오동작 문제? (1)
·Dtrace에 관해 (1)

최근글
·OpenSSL and multi-threads (0)
·ARM 환경에서 OpenCL 사용 (0)
·IoT용 WIFI 모듈 비교 ( MCU ) 클래스 (0)
·Glances - 리눅스 여러 가지 항목을 한 화면에서 모니터링 (0)
·plugin 방식의 로그 분석기 (0)

뜨거운 감자
·나는 인터렉티브한 환경에서 역어셈블 한다. (12)
·GNU REGEX (정규표현식) 프로그래밍 강좌 (7)
·SoCRobotWar 2005 - 신입생 기초 교육자료 (7)
·ASP.NET의 데이터 그리드와 사용자 컨트롤 (7)
·DHTML Editing Control (7)

가장 많이 읽은 글
·[Cache] 2-way Set-Associative 방식이란 무엇일까? (2)
·멀티쓰레드(Pthread) 프로그래밍
·Sorting Algorithm Animation (2)
·GNU REGEX (정규표현식) 프로그래밍 강좌 (7)
·SoCRobotWar 2005 - 신입생 기초 교육자료 (7)

delete date or delete [] data
글쓴이: EzDoum 글쓴날: 2002년 08월 24일 오전 10:58





음... C++ Annotations Version 5.1.1a 
강의 연산자 오버라이딩 볼때
저는 그냥 대수롭지 않게 생각했는데
다시 보니까, 호기심이 들길래..

몇가지 실험을 좀 해봤습니다.

          cout << "step 1" << endl;
          ap = new int[10240000];
          delete [] ap;

          cout << "step 2" << endl;
          ap = new int[10240000];
          delete ap;

          cout << "step 3" << endl;
          xp = new IntArray[10](102400) ;
          delete [] xp;

          cout << "step 4" << endl;
          xp = new IntArray[10](102400) ;
          delete  xp;


이런 4가지 경우의 수를 만들어서
컴파일러와 os에서 동작을 자세히 모니터링해봤습니다.

step 1의 경우엔,,,

	  ap = new int[102400];
 8048bba:	68 00 40 06 00       	push   $0x64000
 8048bbf:	e8 b0 fb ff ff       	call   8048774 <_init+0xe0>
 8048bc4:	83 c4 04             	add    $0x4,%esp
 8048bc7:	89 c0                	mov    %eax,%eax
 8048bc9:	89 45 f8             	mov    %eax,0xfffffff8(%ebp)

이런 어셈블리 코드가 만들어 졌는데
대충 분석을 해보면... int[102400]에 해당하는 메모리 블럭이
통체로 할당이 되었습니다.. 아마도 malloc에 사이지를
넘겨서.,. 호출했겠지요..
그래서 os에서는 


old_mmap(NULL, 40964096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000

이렇게 메모리 블럭이 할당이 되고...
주소를 반환했습죠 0x4016a000

반환을 볼까요..

  	  delete [] ap;
 8048bcc:	83 7d f8 00          	cmpl   $0x0,0xfffffff8(%ebp)
 8048bd0:	74 0e                	je     8048be0 <main+0x154>
 8048bd2:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
 8048bd5:	50                   	push   %eax
 8048bd6:	e8 c9 fb ff ff       	call   80487a4 <_init+0x110>
 8048bdb:	83 c4 04             	add    $0x4,%esp
 8048bde:	eb 00                	jmp    8048be0 <main+0x154>

반환에서 보면 그리 별다른 것은 없고..
포인터 주소가 정당한 값이라면 free해주라는 내용입니다.
그래서 os는
munmap(0x4016a000, 40964096)            = 0
를 해주었구요

step 2를 보면...
delete할때 []가 없어서 어셈코드는 약간 틀려졌습니다만

	  delete ap;
 8048c14:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
 8048c17:	50                   	push   %eax
 8048c18:	e8 97 fb ff ff       	call   80487b4 <_init+0x120>
 8048c1d:	83 c4 04             	add    $0x4,%esp

write(1, "step 2\n", 7step 2
)                 = 7
old_mmap(NULL, 40964096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
munmap(0x4016a000, 40964096)            = 0
write(1, "step 3\n", 7step 3

os에서 하는 일은 비슷하지요..
그런데....

기본 데이터 타입이 아닌... IntArray의 경우엔
둘의 상황이 많이 달랐습니다....
어셈 코드는 아래의 내용을 보고 시스템 트레이스를 보자면,,


write(1, "step 3\n", 7step 3
)                 = 7
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x401cf000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40234000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40299000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x402fe000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40363000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x403c8000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4042d000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40492000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x404f7000
munmap(0x404f7000, 413696)              = 0
munmap(0x40492000, 413696)              = 0
munmap(0x4042d000, 413696)              = 0
munmap(0x403c8000, 413696)              = 0
munmap(0x40363000, 413696)              = 0
munmap(0x402fe000, 413696)              = 0
munmap(0x40299000, 413696)              = 0
munmap(0x40234000, 413696)              = 0
munmap(0x401cf000, 413696)              = 0
munmap(0x4016a000, 413696)              = 0
write(1, "step 4\n", 7step 4
)                 = 7
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x401cf000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40234000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40299000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x402fe000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40363000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x403c8000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4042d000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40492000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x404f7000
munmap(0x4016a000, 413696)              = 0
munmap(0x804a3e3, 97)                   = -1 EINVAL (Invalid argument)

step3은 성공적으로..
할당 해제가 되었지만..
step4에서는 보시는 바와 같이. 두번째 블럭을 해제 하려고 할때
엉터리 주소값과 사이즈 값으로 바로 오류가 납니다..


우리는 여기서 다음을 알수 있습니다.
int나 char같은 경우엔 배열이라도..통으로 하나의 메모리 블럭이
잡혀서,, 비록 배열이지만.. delete를 하게 된다면,,,
그 잡힌 블럭이 통채로 해제가 되어서 메모리 릭이 발생되지 않는다는것이죠

이에 반해서.. 객체는. 각각의 객체가 하나의 블럭을 차지 하기 때문에,,
배열로 된 객체를 해제할때는 컴파일러 한테
이것이 배열이니깐.. 해제할때 신경좀 써줘라고 말을 해주지 않으면,,
엉뚱한 영역을 배열의 연속된 공간으로 보고,,,
munmap(0x804a3e3, 97)                   = -1 EINVAL (Invalid argument)
같은 에러가 발생하게 됩니다..

음 위의 실험은 리눅스에서 한것인데.
컴파일러나 os마다 메모리 할당기법이 달라서.,,
windows에서는 어떤 결론이 나올지 모르겠네요..

암튼... 정석은 배열일때는 delete []를 해주는게 좋을듯 싶네요.

메모리 할당에 관한 적당한 리포트..
http://www.adtmag.com/joop/crarticle.asp?ID=1557
이 글에서도 이런 언급을 찾아 볼수 있네요

The empty brackets tell the compiler that an array was allocated, 
which the compiler could not otherwise know when it sees only a pointer. 
Because the allocation functions for single objects and arrays can be 
separately overloaded or replaced (hence they might use different 
memory pools), it is essential to use the correct form of 
delete-expression—single object or array. 

구현에 관한 다른 자료나 아이디어가 있으면 보충 하도록 하지요;;





class IntArray
{
	public:
		IntArray(unsigned size = 1);
		IntArray(IntArray const &other);
		~IntArray();
		IntArray const &operator=(IntArray const &other);

		// overloaded index operators: 
		int &operator[](unsigned index);        // first 
		int operator[](unsigned index) const;   // second
		
	private:
		void boundary(unsigned index) const;
		void copy(IntArray const &other);
		int *data;
		unsigned size;
};
    

    #include <iostream>

    IntArray::IntArray(unsigned sz)
    :
        size(sz)
    {
        if (size < 1)
        {
            cerr << "IntArray: size of array must be >= 1\n";
            exit(1);
        }
        data = new int [size];
    }

    IntArray::IntArray(IntArray const &other)
    {    
        copy(other);
    }
    
    IntArray::~IntArray()
    {    
        delete data;
    }
    
    IntArray const &IntArray::operator=(IntArray const &other)
    {
        if (this != &other)
        {
            delete data;
            copy(other);
        }
        return *this;
    }

    void IntArray::copy(IntArray const &other)
    {
        size = other.size;
        data = new int [size];
        memcpy(data, other.data, size * sizeof(int));
    }

    int &IntArray::operator[](unsigned index)
    {
        boundary(index);
        return data[index];   
    }

    int IntArray::operator[](unsigned index) const
    {
        boundary(index);
        return data[index];
    }

    void IntArray::boundary(unsigned index) const
    {
        if (index >= size)
        {
            cerr << "IntArray: boundary overflow, index = " <<
                    index << ", should range from 0 to " << size - 1 << endl;
        }
    }
    
int main()
{
	int a, *ap;
	IntArray *xp;
        IntArray
            x(20);                      // 20 ints

        for (int i = 0; i < 20; i++)
            x[i] = i * 2;               // assign the elements
                                
        for (int i = 0; i <= 20; i++)   // produeces boundary overlflow
            cout << "At index " << i << ": value is " << x[i] << endl;
	
	for (int i = 0; i < 5; i++) {
	 	IntArray k(102400);
	}
/**** system call trace 
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
munmap(0x4016a000, 413696)              = 0
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
munmap(0x4016a000, 413696)              = 0
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
munmap(0x4016a000, 413696)              = 0
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
munmap(0x4016a000, 413696)              = 0
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
munmap(0x4016a000, 413696)              = 0
****/

	cout << "step 1" << endl;
	ap = new int[102400];
	delete [] ap;

/**** system call trace 
write(1, "step 1\n", 7step 1
)                 = 7
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
munmap(0x4016a000, 413696)              = 0
****/
	cout << "step 2" << endl;
	ap = new int[102400];
	delete ap;

/**** system call trace 
write(1, "step 2\n", 7step 2
)                 = 7
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
munmap(0x4016a000, 413696)              = 0
****/

	cout << "step 3" << endl;
	xp = new IntArray[10](102400) ;
	delete [] xp;

/**** system call trace 
write(1, "step 3\n", 7step 3
)                 = 7
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x401cf000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40234000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40299000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x402fe000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40363000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x403c8000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4042d000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40492000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x404f7000
munmap(0x404f7000, 413696)              = 0
munmap(0x40492000, 413696)              = 0
munmap(0x4042d000, 413696)              = 0
munmap(0x403c8000, 413696)              = 0
munmap(0x40363000, 413696)              = 0
munmap(0x402fe000, 413696)              = 0
munmap(0x40299000, 413696)              = 0
munmap(0x40234000, 413696)              = 0
munmap(0x401cf000, 413696)              = 0
munmap(0x4016a000, 413696)              = 0
****/
	  
	cout << "step 4" << endl;
	xp = new IntArray[10](102400) ;
	delete  xp;

/**** system call trace 
write(1, "step 4\n", 7step 4
)                 = 7
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4016a000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x401cf000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40234000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40299000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x402fe000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40363000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x403c8000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x4042d000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40492000
old_mmap(NULL, 413696, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x404f7000
munmap(0x4016a000, 413696)              = 0
munmap(0x804a3e3, 97)                   = -1 EINVAL (Invalid argument)
fstat64(0, 0xbffff760)                  = 0
****/
	  
	cin >> a;
}
    
    
inta:     file format elf32-i386

Disassembly of section .init:

08048694 <_init>:
 8048694:	55                   	push   %ebp
 8048695:	89 e5                	mov    %esp,%ebp
 8048697:	53                   	push   %ebx
 8048698:	e8 00 00 00 00       	call   804869d <_init+0x9>
 804869d:	5b                   	pop    %ebx
 804869e:	81 c3 8b 1b 00 00    	add    $0x1b8b,%ebx
 80486a4:	83 bb 50 00 00 00 00 	cmpl   $0x0,0x50(%ebx)
 80486ab:	74 05                	je     80486b2 <_init+0x1e>
 80486ad:	e8 22 01 00 00       	call   80487d4 <_init+0x140>
 80486b2:	89 f6                	mov    %esi,%esi
 80486b4:	e8 b7 01 00 00       	call   8048870 <frame_dummy>
 80486b9:	e8 52 08 00 00       	call   8048f10 <__do_global_ctors_aux>
 80486be:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
 80486c1:	c9                   	leave  
 80486c2:	c3                   	ret    
Disassembly of section .plt:

080486c4 <.plt>:
 80486c4:	ff 35 2c a2 04 08    	pushl  0x804a22c
 80486ca:	ff 25 30 a2 04 08    	jmp    *0x804a230
 80486d0:	00 00                	add    %al,(%eax)
 80486d2:	00 00                	add    %al,(%eax)
 80486d4:	ff 25 34 a2 04 08    	jmp    *0x804a234
 80486da:	68 00 00 00 00       	push   $0x0
 80486df:	e9 e0 ff ff ff       	jmp    80486c4 <_init+0x30>
 80486e4:	ff 25 38 a2 04 08    	jmp    *0x804a238
 80486ea:	68 08 00 00 00       	push   $0x8
 80486ef:	e9 d0 ff ff ff       	jmp    80486c4 <_init+0x30>
 80486f4:	ff 25 3c a2 04 08    	jmp    *0x804a23c
 80486fa:	68 10 00 00 00       	push   $0x10
 80486ff:	e9 c0 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048704:	ff 25 40 a2 04 08    	jmp    *0x804a240
 804870a:	68 18 00 00 00       	push   $0x18
 804870f:	e9 b0 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048714:	ff 25 44 a2 04 08    	jmp    *0x804a244
 804871a:	68 20 00 00 00       	push   $0x20
 804871f:	e9 a0 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048724:	ff 25 48 a2 04 08    	jmp    *0x804a248
 804872a:	68 28 00 00 00       	push   $0x28
 804872f:	e9 90 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048734:	ff 25 4c a2 04 08    	jmp    *0x804a24c
 804873a:	68 30 00 00 00       	push   $0x30
 804873f:	e9 80 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048744:	ff 25 50 a2 04 08    	jmp    *0x804a250
 804874a:	68 38 00 00 00       	push   $0x38
 804874f:	e9 70 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048754:	ff 25 54 a2 04 08    	jmp    *0x804a254
 804875a:	68 40 00 00 00       	push   $0x40
 804875f:	e9 60 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048764:	ff 25 58 a2 04 08    	jmp    *0x804a258
 804876a:	68 48 00 00 00       	push   $0x48
 804876f:	e9 50 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048774:	ff 25 5c a2 04 08    	jmp    *0x804a25c
 804877a:	68 50 00 00 00       	push   $0x50
 804877f:	e9 40 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048784:	ff 25 60 a2 04 08    	jmp    *0x804a260
 804878a:	68 58 00 00 00       	push   $0x58
 804878f:	e9 30 ff ff ff       	jmp    80486c4 <_init+0x30>
 8048794:	ff 25 64 a2 04 08    	jmp    *0x804a264
 804879a:	68 60 00 00 00       	push   $0x60
 804879f:	e9 20 ff ff ff       	jmp    80486c4 <_init+0x30>
 80487a4:	ff 25 68 a2 04 08    	jmp    *0x804a268
 80487aa:	68 68 00 00 00       	push   $0x68
 80487af:	e9 10 ff ff ff       	jmp    80486c4 <_init+0x30>
 80487b4:	ff 25 6c a2 04 08    	jmp    *0x804a26c
 80487ba:	68 70 00 00 00       	push   $0x70
 80487bf:	e9 00 ff ff ff       	jmp    80486c4 <_init+0x30>
 80487c4:	ff 25 70 a2 04 08    	jmp    *0x804a270
 80487ca:	68 78 00 00 00       	push   $0x78
 80487cf:	e9 f0 fe ff ff       	jmp    80486c4 <_init+0x30>
 80487d4:	ff 25 74 a2 04 08    	jmp    *0x804a274
 80487da:	68 80 00 00 00       	push   $0x80
 80487df:	e9 e0 fe ff ff       	jmp    80486c4 <_init+0x30>
Disassembly of section .text:

080487f0 <_start>:
 80487f0:	31 ed                	xor    %ebp,%ebp
 80487f2:	5e                   	pop    %esi
 80487f3:	89 e1                	mov    %esp,%ecx
 80487f5:	83 e4 f8             	and    $0xfffffff8,%esp
 80487f8:	50                   	push   %eax
 80487f9:	54                   	push   %esp
 80487fa:	52                   	push   %edx
 80487fb:	68 3c 8f 04 08       	push   $0x8048f3c
 8048800:	68 94 86 04 08       	push   $0x8048694
 8048805:	51                   	push   %ecx
 8048806:	56                   	push   %esi
 8048807:	68 8c 8a 04 08       	push   $0x8048a8c
 804880c:	e8 33 ff ff ff       	call   8048744 <_init+0xb0>
 8048811:	f4                   	hlt    
 8048812:	90                   	nop    
 8048813:	90                   	nop    

08048814 <gcc2_compiled.>:
 8048814:	90 90 90 90 90 90 90 90 90 90 90 90                 ............

08048820 <__do_global_dtors_aux>:
 8048820:	55                   	push   %ebp
 8048821:	89 e5                	mov    %esp,%ebp
 8048823:	83 3d 20 a0 04 08 00 	cmpl   $0x0,0x804a020
 804882a:	75 38                	jne    8048864 <__do_global_dtors_aux+0x44>
 804882c:	eb 0f                	jmp    804883d <__do_global_dtors_aux+0x1d>
 804882e:	89 f6                	mov    %esi,%esi
 8048830:	8d 50 04             	lea    0x4(%eax),%edx
 8048833:	89 15 1c a0 04 08    	mov    %edx,0x804a01c
 8048839:	8b 00                	mov    (%eax),%eax
 804883b:	ff d0                	call   *%eax
 804883d:	a1 1c a0 04 08       	mov    0x804a01c,%eax
 8048842:	83 38 00             	cmpl   $0x0,(%eax)
 8048845:	75 e9                	jne    8048830 <__do_global_dtors_aux+0x10>
 8048847:	b8 24 87 04 08       	mov    $0x8048724,%eax
 804884c:	85 c0                	test   %eax,%eax
 804884e:	74 0a                	je     804885a <__do_global_dtors_aux+0x3a>
 8048850:	68 24 a0 04 08       	push   $0x804a024
 8048855:	e8 ca fe ff ff       	call   8048724 <_init+0x90>
 804885a:	c7 05 20 a0 04 08 01 	movl   $0x1,0x804a020
 8048861:	00 00 00 
 8048864:	c9                   	leave  
 8048865:	c3                   	ret    
 8048866:	89 f6                	mov    %esi,%esi

08048868 <fini_dummy>:
 8048868:	55                   	push   %ebp
 8048869:	89 e5                	mov    %esp,%ebp
 804886b:	c9                   	leave  
 804886c:	c3                   	ret    
 804886d:	8d 76 00             	lea    0x0(%esi),%esi

08048870 <frame_dummy>:
 8048870:	55                   	push   %ebp
 8048871:	89 e5                	mov    %esp,%ebp
 8048873:	b8 c4 87 04 08       	mov    $0x80487c4,%eax
 8048878:	85 c0                	test   %eax,%eax
 804887a:	74 0f                	je     804888b <frame_dummy+0x1b>
 804887c:	68 c4 a3 04 08       	push   $0x804a3c4
 8048881:	68 24 a0 04 08       	push   $0x804a024
 8048886:	e8 39 ff ff ff       	call   80487c4 <_init+0x130>
 804888b:	c9                   	leave  
 804888c:	c3                   	ret    
 804888d:	8d 76 00             	lea    0x0(%esi),%esi

08048890 <init_dummy>:
 8048890:	55                   	push   %ebp
 8048891:	89 e5                	mov    %esp,%ebp
 8048893:	c9                   	leave  
 8048894:	c3                   	ret    
 8048895:	90                   	nop    
 8048896:	90                   	nop    
 8048897:	90                   	nop    
 8048898:	90                   	nop    
 8048899:	90                   	nop    
 804889a:	90                   	nop    
 804889b:	90                   	nop    
 804889c:	90                   	nop    
 804889d:	90                   	nop    
 804889e:	90                   	nop    
 804889f:	90                   	nop    

080488a0 <__8IntArrayUi>:

    #include <iostream>

    IntArray::IntArray(unsigned sz)
    :
 80488a0:	55                   	push   %ebp
 80488a1:	89 e5                	mov    %esp,%ebp
 80488a3:	56                   	push   %esi
 80488a4:	53                   	push   %ebx
 80488a5:	8b 5d 08             	mov    0x8(%ebp),%ebx
 80488a8:	8b 45 0c             	mov    0xc(%ebp),%eax
 80488ab:	89 43 04             	mov    %eax,0x4(%ebx)
        size(sz)
    {
        if (size < 1)
 80488ae:	83 7b 04 00          	cmpl   $0x0,0x4(%ebx)
 80488b2:	75 1c                	jne    80488d0 <__8IntArrayUi+0x30>
        {
            cerr << "IntArray: size of array must be >= 1\n";
 80488b4:	68 80 8f 04 08       	push   $0x8048f80
 80488b9:	68 30 a3 04 08       	push   $0x804a330
 80488be:	e8 51 fe ff ff       	call   8048714 <_init+0x80>
 80488c3:	83 c4 08             	add    $0x8,%esp
            exit(1);
 80488c6:	6a 01                	push   $0x1
 80488c8:	e8 c7 fe ff ff       	call   8048794 <_init+0x100>
 80488cd:	83 c4 04             	add    $0x4,%esp
        }
        data = new int [size];
 80488d0:	8b 73 04             	mov    0x4(%ebx),%esi
 80488d3:	8d 04 b5 00 00 00 00 	lea    0x0(,%esi,4),%eax
 80488da:	50                   	push   %eax
 80488db:	e8 94 fe ff ff       	call   8048774 <_init+0xe0>
 80488e0:	83 c4 04             	add    $0x4,%esp
 80488e3:	89 c0                	mov    %eax,%eax
 80488e5:	89 03                	mov    %eax,(%ebx)
 80488e7:	89 d8                	mov    %ebx,%eax
 80488e9:	eb 00                	jmp    80488eb <__8IntArrayUi+0x4b>
    }
 80488eb:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
 80488ee:	5b                   	pop    %ebx
 80488ef:	5e                   	pop    %esi
 80488f0:	c9                   	leave  
 80488f1:	c3                   	ret    
 80488f2:	89 f6                	mov    %esi,%esi

080488f4 <__8IntArrayRC8IntArray>:

    IntArray::IntArray(IntArray const &other)
    {    
 80488f4:	55                   	push   %ebp
 80488f5:	89 e5                	mov    %esp,%ebp
 80488f7:	53                   	push   %ebx
 80488f8:	8b 5d 08             	mov    0x8(%ebp),%ebx
        copy(other);
 80488fb:	8b 45 0c             	mov    0xc(%ebp),%eax
 80488fe:	50                   	push   %eax
 80488ff:	53                   	push   %ebx
 8048900:	e8 73 00 00 00       	call   8048978 <copy__8IntArrayRC8IntArray>
 8048905:	83 c4 08             	add    $0x8,%esp
 8048908:	89 d8                	mov    %ebx,%eax
 804890a:	eb 00                	jmp    804890c <__8IntArrayRC8IntArray+0x18>
    }
 804890c:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
 804890f:	c9                   	leave  
 8048910:	c3                   	ret    
 8048911:	8d 76 00             	lea    0x0(%esi),%esi

08048914 <_._8IntArray>:
    
    IntArray::~IntArray()
    {    
 8048914:	55                   	push   %ebp
 8048915:	89 e5                	mov    %esp,%ebp
 8048917:	53                   	push   %ebx
 8048918:	8b 5d 08             	mov    0x8(%ebp),%ebx
        delete data;
 804891b:	8b 03                	mov    (%ebx),%eax
 804891d:	50                   	push   %eax
 804891e:	e8 91 fe ff ff       	call   80487b4 <_init+0x120>
 8048923:	83 c4 04             	add    $0x4,%esp
 8048926:	8b 45 0c             	mov    0xc(%ebp),%eax
 8048929:	83 e0 01             	and    $0x1,%eax
 804892c:	85 c0                	test   %eax,%eax
 804892e:	74 10                	je     8048940 <_._8IntArray+0x2c>
 8048930:	53                   	push   %ebx
 8048931:	e8 7e fe ff ff       	call   80487b4 <_init+0x120>
 8048936:	83 c4 04             	add    $0x4,%esp
 8048939:	eb 05                	jmp    8048940 <_._8IntArray+0x2c>
 804893b:	90                   	nop    
 804893c:	8d 74 26 00          	lea    0x0(%esi,1),%esi
    }
 8048940:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
 8048943:	c9                   	leave  
 8048944:	c3                   	ret    
 8048945:	8d 76 00             	lea    0x0(%esi),%esi

08048948 <__as__8IntArrayRC8IntArray>:
    
    IntArray const &IntArray::operator=(IntArray const &other)
    {
 8048948:	55                   	push   %ebp
 8048949:	89 e5                	mov    %esp,%ebp
 804894b:	53                   	push   %ebx
 804894c:	8b 5d 08             	mov    0x8(%ebp),%ebx
        if (this != &other)
 804894f:	3b 5d 0c             	cmp    0xc(%ebp),%ebx
 8048952:	74 18                	je     804896c <__as__8IntArrayRC8IntArray+0x24>
        {
            delete data;
 8048954:	8b 03                	mov    (%ebx),%eax
 8048956:	50                   	push   %eax
 8048957:	e8 58 fe ff ff       	call   80487b4 <_init+0x120>
 804895c:	83 c4 04             	add    $0x4,%esp
            copy(other);
 804895f:	8b 45 0c             	mov    0xc(%ebp),%eax
 8048962:	50                   	push   %eax
 8048963:	53                   	push   %ebx
 8048964:	e8 0f 00 00 00       	call   8048978 <copy__8IntArrayRC8IntArray>
 8048969:	83 c4 08             	add    $0x8,%esp
        }
        return *this;
 804896c:	89 d8                	mov    %ebx,%eax
 804896e:	eb 00                	jmp    8048970 <__as__8IntArrayRC8IntArray+0x28>
    }
 8048970:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
 8048973:	c9                   	leave  
 8048974:	c3                   	ret    
 8048975:	8d 76 00             	lea    0x0(%esi),%esi

08048978 <copy__8IntArrayRC8IntArray>:

    void IntArray::copy(IntArray const &other)
    {
 8048978:	55                   	push   %ebp
 8048979:	89 e5                	mov    %esp,%ebp
 804897b:	56                   	push   %esi
 804897c:	53                   	push   %ebx
 804897d:	8b 5d 08             	mov    0x8(%ebp),%ebx
        size = other.size;
 8048980:	8b 45 0c             	mov    0xc(%ebp),%eax
 8048983:	8b 50 04             	mov    0x4(%eax),%edx
 8048986:	89 53 04             	mov    %edx,0x4(%ebx)
        data = new int [size];
 8048989:	8b 73 04             	mov    0x4(%ebx),%esi
 804898c:	8d 04 b5 00 00 00 00 	lea    0x0(,%esi,4),%eax
 8048993:	50                   	push   %eax
 8048994:	e8 db fd ff ff       	call   8048774 <_init+0xe0>
 8048999:	83 c4 04             	add    $0x4,%esp
 804899c:	89 c0                	mov    %eax,%eax
 804899e:	89 03                	mov    %eax,(%ebx)
        memcpy(data, other.data, size * sizeof(int));
 80489a0:	8b 43 04             	mov    0x4(%ebx),%eax
 80489a3:	89 c2                	mov    %eax,%edx
 80489a5:	8d 04 95 00 00 00 00 	lea    0x0(,%edx,4),%eax
 80489ac:	50                   	push   %eax
 80489ad:	8b 45 0c             	mov    0xc(%ebp),%eax
 80489b0:	8b 10                	mov    (%eax),%edx
 80489b2:	52                   	push   %edx
 80489b3:	8b 03                	mov    (%ebx),%eax
 80489b5:	50                   	push   %eax
 80489b6:	e8 c9 fd ff ff       	call   8048784 <_init+0xf0>
 80489bb:	83 c4 0c             	add    $0xc,%esp
    }
 80489be:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
 80489c1:	5b                   	pop    %ebx
 80489c2:	5e                   	pop    %esi
 80489c3:	c9                   	leave  
 80489c4:	c3                   	ret    
 80489c5:	8d 76 00             	lea    0x0(%esi),%esi

080489c8 <__vc__8IntArrayUi>:

    int &IntArray::operator[](unsigned index)
    {
 80489c8:	55                   	push   %ebp
 80489c9:	89 e5                	mov    %esp,%ebp
 80489cb:	53                   	push   %ebx
 80489cc:	8b 5d 08             	mov    0x8(%ebp),%ebx
        boundary(index);
 80489cf:	8b 45 0c             	mov    0xc(%ebp),%eax
 80489d2:	50                   	push   %eax
 80489d3:	53                   	push   %ebx
 80489d4:	e8 4b 00 00 00       	call   8048a24 <boundary__C8IntArrayUi>
 80489d9:	83 c4 08             	add    $0x8,%esp
        return data[index];   
 80489dc:	8b 45 0c             	mov    0xc(%ebp),%eax
 80489df:	89 c2                	mov    %eax,%edx
 80489e1:	8d 04 95 00 00 00 00 	lea    0x0(,%edx,4),%eax
 80489e8:	89 c2                	mov    %eax,%edx
 80489ea:	03 13                	add    (%ebx),%edx
 80489ec:	89 d0                	mov    %edx,%eax
 80489ee:	eb 00                	jmp    80489f0 <__vc__8IntArrayUi+0x28>
    }
 80489f0:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
 80489f3:	c9                   	leave  
 80489f4:	c3                   	ret    
 80489f5:	8d 76 00             	lea    0x0(%esi),%esi

080489f8 <__vc__C8IntArrayUi>:

    int IntArray::operator[](unsigned index) const
    {
 80489f8:	55                   	push   %ebp
 80489f9:	89 e5                	mov    %esp,%ebp
 80489fb:	53                   	push   %ebx
 80489fc:	8b 5d 08             	mov    0x8(%ebp),%ebx
        boundary(index);
 80489ff:	8b 45 0c             	mov    0xc(%ebp),%eax
 8048a02:	50                   	push   %eax
 8048a03:	53                   	push   %ebx
 8048a04:	e8 1b 00 00 00       	call   8048a24 <boundary__C8IntArrayUi>
 8048a09:	83 c4 08             	add    $0x8,%esp
        return data[index];
 8048a0c:	8b 45 0c             	mov    0xc(%ebp),%eax
 8048a0f:	8d 14 85 00 00 00 00 	lea    0x0(,%eax,4),%edx
 8048a16:	8b 03                	mov    (%ebx),%eax
 8048a18:	8b 14 10             	mov    (%eax,%edx,1),%edx
 8048a1b:	89 d0                	mov    %edx,%eax
 8048a1d:	eb 00                	jmp    8048a1f <__vc__C8IntArrayUi+0x27>
    }
 8048a1f:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
 8048a22:	c9                   	leave  
 8048a23:	c3                   	ret    

08048a24 <boundary__C8IntArrayUi>:

    void IntArray::boundary(unsigned index) const
    {
 8048a24:	55                   	push   %ebp
 8048a25:	89 e5                	mov    %esp,%ebp
 8048a27:	53                   	push   %ebx
 8048a28:	8b 5d 08             	mov    0x8(%ebp),%ebx
        if (index >= size)
 8048a2b:	8b 45 0c             	mov    0xc(%ebp),%eax
 8048a2e:	3b 43 04             	cmp    0x4(%ebx),%eax
 8048a31:	72 51                	jb     8048a84 <boundary__C8IntArrayUi+0x60>
        {
            cerr << "IntArray: boundary overflow, index = " <<
                    index << ", should range from 0 to " << size - 1 << endl;
 8048a33:	68 d4 86 04 08       	push   $0x80486d4
 8048a38:	8b 43 04             	mov    0x4(%ebx),%eax
 8048a3b:	48                   	dec    %eax
 8048a3c:	50                   	push   %eax
 8048a3d:	68 a6 8f 04 08       	push   $0x8048fa6
 8048a42:	8b 45 0c             	mov    0xc(%ebp),%eax
 8048a45:	50                   	push   %eax
 8048a46:	68 c0 8f 04 08       	push   $0x8048fc0
 8048a4b:	68 30 a3 04 08       	push   $0x804a330
 8048a50:	e8 bf fc ff ff       	call   8048714 <_init+0x80>
 8048a55:	83 c4 08             	add    $0x8,%esp
 8048a58:	89 c0                	mov    %eax,%eax
 8048a5a:	50                   	push   %eax
 8048a5b:	e8 04 fd ff ff       	call   8048764 <_init+0xd0>
 8048a60:	83 c4 08             	add    $0x8,%esp
 8048a63:	89 c0                	mov    %eax,%eax
 8048a65:	50                   	push   %eax
 8048a66:	e8 a9 fc ff ff       	call   8048714 <_init+0x80>
 8048a6b:	83 c4 08             	add    $0x8,%esp
 8048a6e:	89 c0                	mov    %eax,%eax
 8048a70:	50                   	push   %eax
 8048a71:	e8 ee fc ff ff       	call   8048764 <_init+0xd0>
 8048a76:	83 c4 08             	add    $0x8,%esp
 8048a79:	89 c0                	mov    %eax,%eax
 8048a7b:	50                   	push   %eax
 8048a7c:	e8 63 fc ff ff       	call   80486e4 <_init+0x50>
 8048a81:	83 c4 08             	add    $0x8,%esp
        }
    }
 8048a84:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
 8048a87:	c9                   	leave  
 8048a88:	c3                   	ret    
 8048a89:	8d 76 00             	lea    0x0(%esi),%esi

08048a8c <main>:
int main()
    {
 8048a8c:	55                   	push   %ebp
 8048a8d:	89 e5                	mov    %esp,%ebp
 8048a8f:	83 ec 58             	sub    $0x58,%esp
 8048a92:	57                   	push   %edi
 8048a93:	56                   	push   %esi
 8048a94:	53                   	push   %ebx
	int a, *ap;
	IntArray *xp;
        IntArray
            x(20);                      // 20 ints
 8048a95:	6a 14                	push   $0x14
 8048a97:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
 8048a9a:	50                   	push   %eax
 8048a9b:	e8 00 fe ff ff       	call   80488a0 <__8IntArrayUi>
 8048aa0:	83 c4 08             	add    $0x8,%esp

        for (int i = 0; i < 20; i++)
 8048aa3:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
 8048aaa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
 8048ab0:	83 7d e8 13          	cmpl   $0x13,0xffffffe8(%ebp)
 8048ab4:	7e 02                	jle    8048ab8 <main+0x2c>
 8048ab6:	eb 28                	jmp    8048ae0 <main+0x54>
            x[i] = i * 2;               // assign the elements
 8048ab8:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
 8048abb:	50                   	push   %eax
 8048abc:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
 8048abf:	50                   	push   %eax
 8048ac0:	e8 03 ff ff ff       	call   80489c8 <__vc__8IntArrayUi>
 8048ac5:	83 c4 08             	add    $0x8,%esp
 8048ac8:	89 c0                	mov    %eax,%eax
 8048aca:	89 c3                	mov    %eax,%ebx
 8048acc:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
 8048acf:	89 c2                	mov    %eax,%edx
 8048ad1:	8d 04 55 00 00 00 00 	lea    0x0(,%edx,2),%eax
 8048ad8:	89 03                	mov    %eax,(%ebx)
 8048ada:	ff 45 e8             	incl   0xffffffe8(%ebp)
 8048add:	eb d1                	jmp    8048ab0 <main+0x24>
 8048adf:	90                   	nop    
                                
        for (int i = 0; i <= 20; i++)   // produeces boundary overlflow
 8048ae0:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
 8048ae7:	83 7d e4 14          	cmpl   $0x14,0xffffffe4(%ebp)
 8048aeb:	7e 03                	jle    8048af0 <main+0x64>
 8048aed:	eb 67                	jmp    8048b56 <main+0xca>
 8048aef:	90                   	nop    
            cout << "At index " << i << ": value is " << x[i] << endl;
 8048af0:	68 d4 86 04 08       	push   $0x80486d4
 8048af5:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
 8048af8:	50                   	push   %eax
 8048af9:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
 8048afc:	50                   	push   %eax
 8048afd:	e8 c6 fe ff ff       	call   80489c8 <__vc__8IntArrayUi>
 8048b02:	83 c4 08             	add    $0x8,%esp
 8048b05:	89 c0                	mov    %eax,%eax
 8048b07:	8b 10                	mov    (%eax),%edx
 8048b09:	52                   	push   %edx
 8048b0a:	68 e6 8f 04 08       	push   $0x8048fe6
 8048b0f:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
 8048b12:	50                   	push   %eax
 8048b13:	68 f2 8f 04 08       	push   $0x8048ff2
 8048b18:	68 98 a3 04 08       	push   $0x804a398
 8048b1d:	e8 f2 fb ff ff       	call   8048714 <_init+0x80>
 8048b22:	83 c4 08             	add    $0x8,%esp
 8048b25:	89 c0                	mov    %eax,%eax
 8048b27:	50                   	push   %eax
 8048b28:	e8 27 fc ff ff       	call   8048754 <_init+0xc0>
 8048b2d:	83 c4 08             	add    $0x8,%esp
 8048b30:	89 c0                	mov    %eax,%eax
 8048b32:	50                   	push   %eax
 8048b33:	e8 dc fb ff ff       	call   8048714 <_init+0x80>
 8048b38:	83 c4 08             	add    $0x8,%esp
 8048b3b:	89 c0                	mov    %eax,%eax
 8048b3d:	50                   	push   %eax
 8048b3e:	e8 11 fc ff ff       	call   8048754 <_init+0xc0>
 8048b43:	83 c4 08             	add    $0x8,%esp
 8048b46:	89 c0                	mov    %eax,%eax
 8048b48:	50                   	push   %eax
 8048b49:	e8 96 fb ff ff       	call   80486e4 <_init+0x50>
 8048b4e:	83 c4 08             	add    $0x8,%esp
 8048b51:	ff 45 e4             	incl   0xffffffe4(%ebp)
 8048b54:	eb 91                	jmp    8048ae7 <main+0x5b>
	
	for (int i = 0; i < 5; i++) {
 8048b56:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
 8048b5d:	8d 76 00             	lea    0x0(%esi),%esi
 8048b60:	83 7d e4 04          	cmpl   $0x4,0xffffffe4(%ebp)
 8048b64:	7e 02                	jle    8048b68 <main+0xdc>
 8048b66:	eb 30                	jmp    8048b98 <main+0x10c>
	 	IntArray k(102400);
 8048b68:	68 00 90 01 00       	push   $0x19000
 8048b6d:	8d 45 dc             	lea    0xffffffdc(%ebp),%eax
 8048b70:	50                   	push   %eax
 8048b71:	e8 2a fd ff ff       	call   80488a0 <__8IntArrayUi>
 8048b76:	83 c4 08             	add    $0x8,%esp
 8048b79:	eb 0a                	jmp    8048b85 <main+0xf9>
 8048b7b:	90                   	nop    
 8048b7c:	8d 74 26 00          	lea    0x0(%esi,1),%esi
 8048b80:	e8 7f fb ff ff       	call   8048704 <_init+0x70>
 8048b85:	6a 02                	push   $0x2
 8048b87:	8d 45 dc             	lea    0xffffffdc(%ebp),%eax
 8048b8a:	50                   	push   %eax
 8048b8b:	e8 84 fd ff ff       	call   8048914 <_._8IntArray>
 8048b90:	83 c4 08             	add    $0x8,%esp
	}
 8048b93:	ff 45 e4             	incl   0xffffffe4(%ebp)
 8048b96:	eb c8                	jmp    8048b60 <main+0xd4>

	  cout << "step 1" << endl;
 8048b98:	68 d4 86 04 08       	push   $0x80486d4
 8048b9d:	68 fc 8f 04 08       	push   $0x8048ffc
 8048ba2:	68 98 a3 04 08       	push   $0x804a398
 8048ba7:	e8 68 fb ff ff       	call   8048714 <_init+0x80>
 8048bac:	83 c4 08             	add    $0x8,%esp
 8048baf:	89 c0                	mov    %eax,%eax
 8048bb1:	50                   	push   %eax
 8048bb2:	e8 2d fb ff ff       	call   80486e4 <_init+0x50>
 8048bb7:	83 c4 08             	add    $0x8,%esp
	  ap = new int[102400];
 8048bba:	68 00 40 06 00       	push   $0x64000
 8048bbf:	e8 b0 fb ff ff       	call   8048774 <_init+0xe0>
 8048bc4:	83 c4 04             	add    $0x4,%esp
 8048bc7:	89 c0                	mov    %eax,%eax
 8048bc9:	89 45 f8             	mov    %eax,0xfffffff8(%ebp)
  	  delete [] ap;
 8048bcc:	83 7d f8 00          	cmpl   $0x0,0xfffffff8(%ebp)
 8048bd0:	74 0e                	je     8048be0 <main+0x154>
 8048bd2:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
 8048bd5:	50                   	push   %eax
 8048bd6:	e8 c9 fb ff ff       	call   80487a4 <_init+0x110>
 8048bdb:	83 c4 04             	add    $0x4,%esp
 8048bde:	eb 00                	jmp    8048be0 <main+0x154>

	  cout << "step 2" << endl;
 8048be0:	68 d4 86 04 08       	push   $0x80486d4
 8048be5:	68 03 90 04 08       	push   $0x8049003
 8048bea:	68 98 a3 04 08       	push   $0x804a398
 8048bef:	e8 20 fb ff ff       	call   8048714 <_init+0x80>
 8048bf4:	83 c4 08             	add    $0x8,%esp
 8048bf7:	89 c0                	mov    %eax,%eax
 8048bf9:	50                   	push   %eax
 8048bfa:	e8 e5 fa ff ff       	call   80486e4 <_init+0x50>
 8048bff:	83 c4 08             	add    $0x8,%esp
	  ap = new int[102400];
 8048c02:	68 00 40 06 00       	push   $0x64000
 8048c07:	e8 68 fb ff ff       	call   8048774 <_init+0xe0>
 8048c0c:	83 c4 04             	add    $0x4,%esp
 8048c0f:	89 c0                	mov    %eax,%eax
 8048c11:	89 45 f8             	mov    %eax,0xfffffff8(%ebp)
	  delete ap;
 8048c14:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
 8048c17:	50                   	push   %eax
 8048c18:	e8 97 fb ff ff       	call   80487b4 <_init+0x120>
 8048c1d:	83 c4 04             	add    $0x4,%esp

	  cout << "step 3" << endl;
 8048c20:	68 d4 86 04 08       	push   $0x80486d4
 8048c25:	68 0a 90 04 08       	push   $0x804900a
 8048c2a:	68 98 a3 04 08       	push   $0x804a398
 8048c2f:	e8 e0 fa ff ff       	call   8048714 <_init+0x80>
 8048c34:	83 c4 08             	add    $0x8,%esp
 8048c37:	89 c0                	mov    %eax,%eax
 8048c39:	50                   	push   %eax
 8048c3a:	e8 a5 fa ff ff       	call   80486e4 <_init+0x50>
 8048c3f:	83 c4 08             	add    $0x8,%esp
	  xp = new IntArray[10](102400) ;
 8048c42:	6a 54                	push   $0x54
 8048c44:	e8 2b fb ff ff       	call   8048774 <_init+0xe0>
 8048c49:	83 c4 04             	add    $0x4,%esp
 8048c4c:	89 c0                	mov    %eax,%eax
 8048c4e:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
 8048c51:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
 8048c58:	8b 7d d8             	mov    0xffffffd8(%ebp),%edi
 8048c5b:	83 c7 04             	add    $0x4,%edi
 8048c5e:	c7 47 fc 0a 00 00 00 	movl   $0xa,0xfffffffc(%edi)
 8048c65:	89 fe                	mov    %edi,%esi
 8048c67:	89 75 d4             	mov    %esi,0xffffffd4(%ebp)
 8048c6a:	89 75 d0             	mov    %esi,0xffffffd0(%ebp)
 8048c6d:	c7 45 cc 09 00 00 00 	movl   $0x9,0xffffffcc(%ebp)
 8048c74:	83 7d cc 00          	cmpl   $0x0,0xffffffcc(%ebp)
 8048c78:	7c 36                	jl     8048cb0 <main+0x224>
 8048c7a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
 8048c80:	68 00 90 01 00       	push   $0x19000
 8048c85:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
 8048c88:	51                   	push   %ecx
 8048c89:	e8 12 fc ff ff       	call   80488a0 <__8IntArrayUi>
 8048c8e:	83 c4 08             	add    $0x8,%esp
 8048c91:	83 45 d0 08          	addl   $0x8,0xffffffd0(%ebp)
 8048c95:	ff 4d cc             	decl   0xffffffcc(%ebp)
 8048c98:	83 7d cc ff          	cmpl   $0xffffffff,0xffffffcc(%ebp)
 8048c9c:	75 02                	jne    8048ca0 <main+0x214>
 8048c9e:	eb 02                	jmp    8048ca2 <main+0x216>
 8048ca0:	eb de                	jmp    8048c80 <main+0x1f4>
 8048ca2:	eb 0c                	jmp    8048cb0 <main+0x224>
 8048ca4:	e8 5b fa ff ff       	call   8048704 <_init+0x70>
 8048ca9:	8d b4 26 00 00 00 00 	lea    0x0(%esi,1),%esi
 8048cb0:	eb 05                	jmp    8048cb7 <main+0x22b>
 8048cb2:	e8 4d fa ff ff       	call   8048704 <_init+0x70>
 8048cb7:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
 8048cba:	89 4d f4             	mov    %ecx,0xfffffff4(%ebp)
	  delete [] xp;
 8048cbd:	83 7d f4 00          	cmpl   $0x0,0xfffffff4(%ebp)
 8048cc1:	74 52                	je     8048d15 <main+0x289>
 8048cc3:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
 8048cc6:	83 c0 fc             	add    $0xfffffffc,%eax
 8048cc9:	8b 10                	mov    (%eax),%edx
 8048ccb:	89 d0                	mov    %edx,%eax
 8048ccd:	8d 14 c5 00 00 00 00 	lea    0x0(,%eax,8),%edx
 8048cd4:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx
 8048cd7:	01 d1                	add    %edx,%ecx
 8048cd9:	89 4d c4             	mov    %ecx,0xffffffc4(%ebp)
 8048cdc:	8d 74 26 00          	lea    0x0(%esi,1),%esi
 8048ce0:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
 8048ce3:	39 4d f4             	cmp    %ecx,0xfffffff4(%ebp)
 8048ce6:	75 08                	jne    8048cf0 <main+0x264>
 8048ce8:	eb 1a                	jmp    8048d04 <main+0x278>
 8048cea:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
 8048cf0:	83 45 c4 f8          	addl   $0xfffffff8,0xffffffc4(%ebp)
 8048cf4:	6a 02                	push   $0x2
 8048cf6:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
 8048cf9:	51                   	push   %ecx
 8048cfa:	e8 15 fc ff ff       	call   8048914 <_._8IntArray>
 8048cff:	83 c4 08             	add    $0x8,%esp
 8048d02:	eb dc                	jmp    8048ce0 <main+0x254>
 8048d04:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
 8048d07:	83 c0 fc             	add    $0xfffffffc,%eax
 8048d0a:	50                   	push   %eax
 8048d0b:	e8 94 fa ff ff       	call   80487a4 <_init+0x110>
 8048d10:	83 c4 04             	add    $0x4,%esp
 8048d13:	eb 00                	jmp    8048d15 <main+0x289>
	  
	  cout << "step 4" << endl;
 8048d15:	68 d4 86 04 08       	push   $0x80486d4
 8048d1a:	68 11 90 04 08       	push   $0x8049011
 8048d1f:	68 98 a3 04 08       	push   $0x804a398
 8048d24:	e8 eb f9 ff ff       	call   8048714 <_init+0x80>
 8048d29:	83 c4 08             	add    $0x8,%esp
 8048d2c:	89 c0                	mov    %eax,%eax
 8048d2e:	50                   	push   %eax
 8048d2f:	e8 b0 f9 ff ff       	call   80486e4 <_init+0x50>
 8048d34:	83 c4 08             	add    $0x8,%esp
	  xp = new IntArray[10](102400) ;
 8048d37:	6a 54                	push   $0x54
 8048d39:	e8 36 fa ff ff       	call   8048774 <_init+0xe0>
 8048d3e:	83 c4 04             	add    $0x4,%esp
 8048d41:	89 c0                	mov    %eax,%eax
 8048d43:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
 8048d46:	c7 45 bc 00 00 00 00 	movl   $0x0,0xffffffbc(%ebp)
 8048d4d:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
 8048d50:	83 c1 04             	add    $0x4,%ecx
 8048d53:	89 4d b4             	mov    %ecx,0xffffffb4(%ebp)
 8048d56:	8b 4d b4             	mov    0xffffffb4(%ebp),%ecx
 8048d59:	c7 41 fc 0a 00 00 00 	movl   $0xa,0xfffffffc(%ecx)
 8048d60:	8b 4d b4             	mov    0xffffffb4(%ebp),%ecx
 8048d63:	89 4d b8             	mov    %ecx,0xffffffb8(%ebp)
 8048d66:	8b 4d b8             	mov    0xffffffb8(%ebp),%ecx
 8048d69:	89 4d bc             	mov    %ecx,0xffffffbc(%ebp)
 8048d6c:	8b 4d b8             	mov    0xffffffb8(%ebp),%ecx
 8048d6f:	89 4d b0             	mov    %ecx,0xffffffb0(%ebp)
 8048d72:	c7 45 ac 09 00 00 00 	movl   $0x9,0xffffffac(%ebp)
 8048d79:	83 7d ac 00          	cmpl   $0x0,0xffffffac(%ebp)
 8048d7d:	7c 31                	jl     8048db0 <main+0x324>
 8048d7f:	90                   	nop    
 8048d80:	68 00 90 01 00       	push   $0x19000
 8048d85:	8b 4d b0             	mov    0xffffffb0(%ebp),%ecx
 8048d88:	51                   	push   %ecx
 8048d89:	e8 12 fb ff ff       	call   80488a0 <__8IntArrayUi>
 8048d8e:	83 c4 08             	add    $0x8,%esp
 8048d91:	83 45 b0 08          	addl   $0x8,0xffffffb0(%ebp)
 8048d95:	ff 4d ac             	decl   0xffffffac(%ebp)
 8048d98:	83 7d ac ff          	cmpl   $0xffffffff,0xffffffac(%ebp)
 8048d9c:	75 02                	jne    8048da0 <main+0x314>
 8048d9e:	eb 02                	jmp    8048da2 <main+0x316>
 8048da0:	eb de                	jmp    8048d80 <main+0x2f4>
 8048da2:	eb 0c                	jmp    8048db0 <main+0x324>
 8048da4:	e8 5b f9 ff ff       	call   8048704 <_init+0x70>
 8048da9:	8d b4 26 00 00 00 00 	lea    0x0(%esi,1),%esi
 8048db0:	eb 05                	jmp    8048db7 <main+0x32b>
 8048db2:	e8 4d f9 ff ff       	call   8048704 <_init+0x70>
 8048db7:	8b 4d bc             	mov    0xffffffbc(%ebp),%ecx
 8048dba:	89 4d f4             	mov    %ecx,0xfffffff4(%ebp)
	  delete  xp;
 8048dbd:	83 7d f4 00          	cmpl   $0x0,0xfffffff4(%ebp)
 8048dc1:	74 10                	je     8048dd3 <main+0x347>
 8048dc3:	6a 03                	push   $0x3
 8048dc5:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
 8048dc8:	50                   	push   %eax
 8048dc9:	e8 46 fb ff ff       	call   8048914 <_._8IntArray>
 8048dce:	83 c4 08             	add    $0x8,%esp
 8048dd1:	eb 00                	jmp    8048dd3 <main+0x347>
	  
	cin >> a;
 8048dd3:	8d 45 fc             	lea    0xfffffffc(%ebp),%eax
 8048dd6:	50                   	push   %eax
 8048dd7:	68 60 a3 04 08       	push   $0x804a360
 8048ddc:	e8 13 f9 ff ff       	call   80486f4 <_init+0x60>
 8048de1:	83 c4 08             	add    $0x8,%esp
 8048de4:	eb 0a                	jmp    8048df0 <main+0x364>
 8048de6:	e8 19 f9 ff ff       	call   8048704 <_init+0x70>
 8048deb:	90                   	nop    
 8048dec:	8d 74 26 00          	lea    0x0(%esi,1),%esi
 8048df0:	6a 02                	push   $0x2
 8048df2:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
 8048df5:	50                   	push   %eax
 8048df6:	e8 19 fb ff ff       	call   8048914 <_._8IntArray>
 8048dfb:	83 c4 08             	add    $0x8,%esp
 8048dfe:	31 c0                	xor    %eax,%eax
 8048e00:	e9 00 01 00 00       	jmp    8048f05 <main+0x479>
 8048e05:	e9 fb 00 00 00       	jmp    8048f05 <main+0x479>
 8048e0a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
 8048e10:	6a 02                	push   $0x2
 8048e12:	8d 45 dc             	lea    0xffffffdc(%ebp),%eax
 8048e15:	50                   	push   %eax
 8048e16:	e8 f9 fa ff ff       	call   8048914 <_._8IntArray>
 8048e1b:	83 c4 08             	add    $0x8,%esp
 8048e1e:	e9 5d fd ff ff       	jmp    8048b80 <main+0xf4>
 8048e23:	83 7d d4 00          	cmpl   $0x0,0xffffffd4(%ebp)
 8048e27:	74 3d                	je     8048e66 <main+0x3da>
 8048e29:	ba 09 00 00 00       	mov    $0x9,%edx
 8048e2e:	89 d0                	mov    %edx,%eax
 8048e30:	2b 45 cc             	sub    0xffffffcc(%ebp),%eax
 8048e33:	8d 14 c5 00 00 00 00 	lea    0x0(,%eax,8),%edx
 8048e3a:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
 8048e3d:	01 d1                	add    %edx,%ecx
 8048e3f:	89 4d c8             	mov    %ecx,0xffffffc8(%ebp)
 8048e42:	8b 4d c8             	mov    0xffffffc8(%ebp),%ecx
 8048e45:	39 4d d4             	cmp    %ecx,0xffffffd4(%ebp)
 8048e48:	75 06                	jne    8048e50 <main+0x3c4>
 8048e4a:	eb 18                	jmp    8048e64 <main+0x3d8>
 8048e4c:	8d 74 26 00          	lea    0x0(%esi,1),%esi
 8048e50:	83 45 c8 f8          	addl   $0xfffffff8,0xffffffc8(%ebp)
 8048e54:	6a 00                	push   $0x0
 8048e56:	8b 4d c8             	mov    0xffffffc8(%ebp),%ecx
 8048e59:	51                   	push   %ecx
 8048e5a:	e8 b5 fa ff ff       	call   8048914 <_._8IntArray>
 8048e5f:	83 c4 08             	add    $0x8,%esp
 8048e62:	eb de                	jmp    8048e42 <main+0x3b6>
 8048e64:	eb 00                	jmp    8048e66 <main+0x3da>
 8048e66:	e9 39 fe ff ff       	jmp    8048ca4 <main+0x218>
 8048e6b:	90                   	nop    
 8048e6c:	8d 74 26 00          	lea    0x0(%esi,1),%esi
 8048e70:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
 8048e73:	51                   	push   %ecx
 8048e74:	e8 2b f9 ff ff       	call   80487a4 <_init+0x110>
 8048e79:	83 c4 04             	add    $0x4,%esp
 8048e7c:	e9 31 fe ff ff       	jmp    8048cb2 <main+0x226>
 8048e81:	83 7d bc 00          	cmpl   $0x0,0xffffffbc(%ebp)
 8048e85:	74 3f                	je     8048ec6 <main+0x43a>
 8048e87:	ba 09 00 00 00       	mov    $0x9,%edx
 8048e8c:	89 d0                	mov    %edx,%eax
 8048e8e:	2b 45 ac             	sub    0xffffffac(%ebp),%eax
 8048e91:	8d 14 c5 00 00 00 00 	lea    0x0(,%eax,8),%edx
 8048e98:	8b 4d bc             	mov    0xffffffbc(%ebp),%ecx
 8048e9b:	01 d1                	add    %edx,%ecx
 8048e9d:	89 4d a8             	mov    %ecx,0xffffffa8(%ebp)
 8048ea0:	8b 4d a8             	mov    0xffffffa8(%ebp),%ecx
 8048ea3:	39 4d bc             	cmp    %ecx,0xffffffbc(%ebp)
 8048ea6:	75 08                	jne    8048eb0 <main+0x424>
 8048ea8:	eb 1a                	jmp    8048ec4 <main+0x438>
 8048eaa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
 8048eb0:	83 45 a8 f8          	addl   $0xfffffff8,0xffffffa8(%ebp)
 8048eb4:	6a 00                	push   $0x0
 8048eb6:	8b 4d a8             	mov    0xffffffa8(%ebp),%ecx
 8048eb9:	51                   	push   %ecx
 8048eba:	e8 55 fa ff ff       	call   8048914 <_._8IntArray>
 8048ebf:	83 c4 08             	add    $0x8,%esp
 8048ec2:	eb dc                	jmp    8048ea0 <main+0x414>
 8048ec4:	eb 00                	jmp    8048ec6 <main+0x43a>
 8048ec6:	e9 d9 fe ff ff       	jmp    8048da4 <main+0x318>
 8048ecb:	90                   	nop    
 8048ecc:	8d 74 26 00          	lea    0x0(%esi,1),%esi
 8048ed0:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
 8048ed3:	51                   	push   %ecx
 8048ed4:	e8 cb f8 ff ff       	call   80487a4 <_init+0x110>
 8048ed9:	83 c4 04             	add    $0x4,%esp
 8048edc:	e9 d1 fe ff ff       	jmp    8048db2 <main+0x326>
 8048ee1:	6a 02                	push   $0x2
 8048ee3:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
 8048ee6:	50                   	push   %eax
 8048ee7:	e8 28 fa ff ff       	call   8048914 <_._8IntArray>
 8048eec:	83 c4 08             	add    $0x8,%esp
 8048eef:	e9 f2 fe ff ff       	jmp    8048de6 <main+0x35a>
 8048ef4:	eb 0a                	jmp    8048f00 <main+0x474>
 8048ef6:	e8 09 f8 ff ff       	call   8048704 <_init+0x70>
 8048efb:	90                   	nop    
 8048efc:	8d 74 26 00          	lea    0x0(%esi,1),%esi
 8048f00:	e8 2f f8 ff ff       	call   8048734 <_init+0xa0>
    }
 8048f05:	8d 65 9c             	lea    0xffffff9c(%ebp),%esp
 8048f08:	5b                   	pop    %ebx
 8048f09:	5e                   	pop    %esi
 8048f0a:	5f                   	pop    %edi
 8048f0b:	c9                   	leave  
 8048f0c:	c3                   	ret    
 8048f0d:	90                   	nop    
 8048f0e:	90                   	nop    
 8048f0f:	90                   	nop    

08048f10 <__do_global_ctors_aux>:
 8048f10:	55                   	push   %ebp
 8048f11:	89 e5                	mov    %esp,%ebp
 8048f13:	53                   	push   %ebx
 8048f14:	bb 18 a2 04 08       	mov    $0x804a218,%ebx
 8048f19:	83 3d 18 a2 04 08 ff 	cmpl   $0xffffffff,0x804a218
 8048f20:	74 0c                	je     8048f2e <__do_global_ctors_aux+0x1e>
 8048f22:	8b 03                	mov    (%ebx),%eax
 8048f24:	ff d0                	call   *%eax
 8048f26:	83 c3 fc             	add    $0xfffffffc,%ebx
 8048f29:	83 3b ff             	cmpl   $0xffffffff,(%ebx)
 8048f2c:	75 f4                	jne    8048f22 <__do_global_ctors_aux+0x12>
 8048f2e:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
 8048f31:	c9                   	leave  
 8048f32:	c3                   	ret    
 8048f33:	90                   	nop    

08048f34 <init_dummy>:
 8048f34:	55                   	push   %ebp
 8048f35:	89 e5                	mov    %esp,%ebp
 8048f37:	c9                   	leave  
 8048f38:	c3                   	ret    
 8048f39:	90                   	nop    
 8048f3a:	90                   	nop    
 8048f3b:	90                   	nop    
Disassembly of section .fini:

08048f3c <_fini>:
 8048f3c:	55                   	push   %ebp
 8048f3d:	89 e5                	mov    %esp,%ebp
 8048f3f:	53                   	push   %ebx
 8048f40:	e8 00 00 00 00       	call   8048f45 <_etext+0x9>
 8048f45:	5b                   	pop    %ebx
 8048f46:	81 c3 e3 12 00 00    	add    $0x12e3,%ebx
 8048f4c:	e8 cf f8 ff ff       	call   8048820 <__do_global_dtors_aux>
 8048f51:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
 8048f54:	c9                   	leave  
 8048f55:	c3                   	ret        


[분류: C/C++ 인쇄용 페이지 본문 email로 보내기 ]

<  Data, Bss Segment 사이즈 변화 | 배열 선언 관련 질문  >
delete date or delete [] data | 답장: 2개 | 본문에 답장
정렬 :  
답장 EzDoum 2002년 08월 24일 오전 10:58 [ 이글에 답장 | 본문에 답장 | 책갈피 ]
메모리 할당에 관한 다른 작은 재미는
http://www.parashift.com/c++-faq-lite/dtors.html
에서 [11.10] What is "placement new" and why would I use it?
에 관한것을 보세요 이런 용법도 가능하니깐요;;


[수정]

답장 익명 2003년 04월 05일 오후 04:57 [ 이글에 답장 | 본문에 답장 | 책갈피 ]
네 어떤 컴파일러는 delete array; 해도 다 지워주지만

어떤 컴파일러는 그렇지 않은 것으로 알고 있습니다.

님께서 테스트 해 본 시스템의 컴파일러는 그렇구요.


상당히 컴파일러-디펜던트한 문제이네요.

위에서 님께서 쓰셨던 대로 delete []array; 하는게 정석입니다.

delete date or delete [] data | 답장: 2개 | 본문에 답장
정렬 :  

답장 쓰기
글을 올리시려면 로그인 (사용자 등록) 하셔야 합니다.

검색
Google

분류
·공지 (6)
·인터넷 (87)
·하드웨어 (260)
·C/C++ (65)
·어셈블리 (7)
·리눅스 (136)
·리눅스 커널 (67)
·윈도우즈 (25)
·데이터베이스 (20)
·보안 (16)
·.NET (25)
·그래픽 (13)
·책소개 (42)
·호기심 천국 (80)
·잡담 (111)
·사랑 (3)

전체 본문수: 963
전체 답장수: 525


분류 : C/C++
최근글
최근글
가장 많이 읽은 글
·Sorting Algorithm Animation (2)
뜨거운 감자
·눈으로 보는 자료구조 (5)

EzDoum투표
이지도움 어때요?
이게 뭐야. 다시 안올란다. --;
아이 좋아라~ +_+;
관심없다.
먼가는 있는거 같은데 뭐하는 곳이지?
기타 (자유게시판에 글로 남겨 주세요)
[ 결과 | 투표 ]

랜덤 링크
http://kldp.net


 Home ^ BACK TO TOP ^ EzDoum - 도움이 필요하세요~??
 Powered by KorWeblog 1.5.8 Copyleft © 2001 EzDoum, 관리자: EzDoum