1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/////////////
//대입 연산자//
////////////
 
class CCopyStudy {
public:
    CCopyStudy(int nParam) {
        m_pnData = new int;
 
        *m_pnData = nParam;
    }
    
    //얕은 복사의 오류를 범하지 않기 위해 값을 복사한 깊은 복사 형태//
    CCopyStudy(const CCopyStudy &rhs) {
 
        m_pnData = new int;
        
        *m_pnData = *rhs.m_pnData;
    }
 
    //단순대입 연산자를 사용했을시 얕은 복사 방지를 위한 코드 추가//
    CCopyStudy& operator=(const CCopyStudy &rhs) {
        
        *m_pnData = *rhs.m_pnData;
 
        return *this;
    }
    
    ~CCopyStudy() {
        delete m_pnData;
    }
 
    int GetData() {
        if(m_pnData != NULL) {
            return *m_pnData;
        }
        return 0;
    }
 
private:
    int *m_pnData = nullptr;
}
 
int main(void) {
    
    CCopyStudy a(10);
    
    //매개변수를 통한 복사//
    //얕은 복사를 방지 하기 위한 깊은 복사 형태를 주의 해야 됨//
    CCopyStudy b(a);
 
    //단순 대입 연산자를 사용 하게 될 경우 오류가 발생//
    //단순 대입 연산자는 얕은 복사를 사용하게 되어서 메모리 해제시 오류가 발생//
    //operator 단순 대입 연산자를 사용 해야 됨//
 
    CCopyStudy c(20);
    a = c;   //a.operator(c); //사용 방법이 2가지가 있음//
    
    
    
    return 0;
}
cs


저작자표시
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
깊은 복사 
 - 복사에 의해 실제로 두 개의 값이 생성되는 것
 
얕은 복사 
 - 대상이 되는 값은 여전히 하나뿐인데 접근 포인터만 둘로 늘어나는 것
 
 
#include "stdafx.h"
#include <iostream>
using namespace std;
 
//얕은 복사 기본 정의(?)//
int _tmain(int argc, TCHAR* argv[]) {
    
    //대상이 하나
    int nScoreData = 10;
    
    int *pA, *pB;
    
    //하나의 대항을 향해 접근 포인터가 둘로 늘어남    
    pA = &nScoreData;
    pB = &nscoreData;
 
    return 0;
}
 
 
//////////////////
//얕은 복사의 문제점//
/////////////////
int _tmain(int argc, TCHAR* argv[]) {
        
    int *pA, *pB;
 
    pA = new int;
    *pA = 10;
    
    pB = new int;
    pB = pA; //얕은 복사의 표본(?)
 
    cout << *pA << endl;
    cout << *pB << endl;
    
    delete pA;
    delete pB;    
    
    return 0;
}
 
- 얕은 복사로 인하여 하나의 동적 생성된 인스턴스에 접근 포인터가 2개로 늘어 난 상태에서 
  메모리 해제를 해버리면 이미 해제가 된 상태인데 또 해제를 할려고 하니 에러가 발생됨
 
- 또한 pB가 생성한 인스턴스는 접근 불가능한 상태가 되버린다
 
- 그래서 포인터가 가리키는 주소를 변경 하는게 아니라 포인터가 가리키고 있는 메모리의 내용을 복사 해야 됨.
 
pB = pA; //얕은 복사의 표본(?)
이 형태를 변형 해야 한다.
 
*pB = *pA; //포인터가 가리키고 있는 메모리의 내용(값)을 복사
 
이렇게 복사를 하게 되면 메모리 해제를 하더라도 동적으로 생성된 모든(pA,pB) 인스턴스가 정상적으로 해제가 된다.
cs


저작자표시

+ Recent posts

티스토리툴바