연산자 오버로딩

 - 사용자 정의 타입에도 연산자를 사용할 수 있게 하는 문법

 

#include <iostream>
using namespace std;
class Point {
    int x;
    int y;
    
public:
    Point(int _x = 0, int _y = 0) : x(_x), y(_y) {}
    void Print() const { cout << x << ',' << y << endl; }
    const Point operator+(const Point& arg) const {
        Point pt;
        pt.x = this->x + arg.x;
        pt.y = this->y + arg.y;
        
        return pt;
    }
    
};

int main() {
    Point p1(2,3), p2(5,5);
    Point p3;
    
    p3 = p1 + p2; //컴파일러가 p1.operator+(p2)로 변해서 인식함
    p3.Print();
    p3 = p1.operator+(p2);
    p3.Print();

    //전위 연산자와 후위 연산자 구별 하는 방법
    //후위 연산자는 아무 의미 없는 값을 넣어서 구별 한다.
    ++p1; //p1.operator++;
    p2++; //p2.operator++(0);
    



    return 0;
}
 

위 연산자 오버로딩 예제는 멤버함수를 이용한 연산자 오버로딩

 

전역 함수를 이용한 연산자 오버로딩을 사용하고 싶으면 

 

operator+(p1,p2); 이런씩으로 구현을 해야 한다.

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
///////////////////////
///////C++ 집합관계//////
//////////////////////
 
두가지의 집합관계가 존재함
 - Composition
 - Aggregation
 
Composition 관계는 구성 요소들도 함께 소멸 함.
Aggregation 관계는 개별적으로 분리되어 독립적으로 활용(독립적으로 소멸됨).
 
class CNode {
    friend class CMyList;
 
public:
    explicit CNode(const char *pszName) {
        strcpy(m_szName,pszName);
    }
 
private:
    char m_szName[20];
    CNode *pNext = nullptr;
};
 
class CMyList {
 
public:
    CMyList() : m_HeadNode("Test Head") {}
    ~CMyList() {
        
        CNode *pNode = m_HeadNode.pNext;
        CNode *pDelete = nullptr;
 
        while(pNode) {
            
            pDelete = pNode;
            pNode   = pNode->pNext;
            delete pDelete;
        }
        
        m_HeadNode,pNext = nullptr;
    }
 
    void AddNewNode(const char *pszName) {
        
        CNode *pNode = new CNode(pszName);
 
        pNode->pNext = m_HeadNode.pNext;
        m_HeadNode.pNext = pNode;
    }
 
    void Print() {
 
        CNode *pNode = m_HeadNode.pNext;
    
        while(pNode) {
            cout << pNode->m_szName << endl;
            pNode = pNode->Next;    
        }
    }
 
private:
    CNode m_HeadNode;
};
 
class CMyUI {
public:
    CMyUI(CMyList &rList) : m_list(rList);
    int printMenu() {
        cout << "[1]Add\t" << "[2]Print\t" << "[0]Exit\n";
        cout.flush();
        int nInput = 0;
        cin >> nInput;        
 
        return nInpit;
    }
 
    void Run() {
        char szName[20];
        int nInput = 0;
 
        whild((nInput = printMenu()) > 0) {
            
            switch(nInput) {
                case 1:
                cout << "이름: ";
                cout.flush();
                cin >> szName;
                m_list.AddNewNode(szName); 
                break;            
                
                case 2:                
                m_list.print();
                break;
 
                default:
                break;
 
            }
        }
    }
 
private:
    //UI 클래스 내부에 자료구조가 포함된다.
    //전형적인 Composition관계
    CMyList m_list;
    
    //위 Composition관계를 Aggregation관계로 변경 하기 위해서는 포인터나 참조로 선언 해야 된다.
    //참조로 선언된 변수는 생성자에서 무조건 초기화를 해야 됨.
    CMyList &m_list;
};
 
int main(void) {
 
    CMyUI ui;
    ui.Run();    
 
    //참조로 선언을 했기 때문에 선언 형태도 변경됨//
    //CList 와 CMyUI의 객체를 별도로 선언하고 연결 했기 때문에 Aggregation 관계로 변경 된다.
    CList list;
    CMyUI ui2(list);
    ui2.Run();
    
 
    return 0;
}
 
참고 문헌) 이것이 C++이다

 
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
/////////////
//대입 연산자//
////////////
 
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



a 파일이 안올라가는건 버그가 아니라 svn 설정 때문에 그렇습니다. 


터미널에서

vi ~/.subversion/config 


라고 타이핑 하신후 enter 하시면 svn 설정 관련 파일이 열리는데요.. 중간쯤 보면 global-ignores 라는 파트가 있습니다. 


그곳에 *.a 라고 되어 있는 파트를 지워주시면 commit시 a파일도 올라갑니다.


global-ignores = *.o *.lo *.la *.al .libs *.so *.so.[0-9]* *.pyc *.pyo



터미널에서 편집시 

커서 위치에서 x 버튼을 클릭 하면 삭제 됩니다. 


다 편집 후 


:w 명령어 입력후 터미널을 닫으면 저장이 완료 됩니다. 




java.lang.UnsatisfiedLinkError: dlopen failed: cannot locate symbol "srand" referenced by


위 오류는 Application.mk 에 APP_PLATFORM=android-19 추가 하면 됩니다.




__android_log_print(ANDROID_LOG_DEBUG, "cocos2d-x debug info", buf);


에 대한 오류는


아래와 같이 수정

 __android_log_print(ANDROID_LOG_DEBUG, "cocos2d-x debug info", "%s", buf);


keytool -exportcert -alias ef2-02 -keystore ./EF2_android_keystore | openssl sha1 -binary | openssl base64


keytool -exportcert -alias (키네임) -keystore ./(키파일네임) | openssl sha1 -binary | openssl base64




코코스 안드로이드 빌드 중 


error: 'sort' is not a member of 'std


위 같은 오류가 발생 하면 


#include <algorithm> 


추가 해주면 끝


   

Project Properties > Android > Is Library 가 체크되어 있는지를 확인한다.

만약 체크되어 있다면 체크해제 후 재 실행하면 해결 할 수 있다.


이상입니다.

+ Recent posts