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
#include <iostream>
 
/**
* 연산자 오버로딩
*/
 
using namespace std;
 
class Point {
 
    int x;
    int y;
 
public:
    explicit Point( int _x, int _y ){ x = _x; y = _y; }    
 
    /**
    * 단항
    */
    const Point&operator++(){
        ++x;
        ++y;
        return *this;
    }
    const Point operator++(int){
        Point tmp( x, y );
        ++x;
        ++y;
        return tmp;
    }
 
    /**
    * 이항
    */
    bool operator== ( const Point& p2 ){
 
        return x == p2.x && y == p2.y ? true : false;
    }
    void Print() { cout<<x<<","<<y<<endl;}
 
 
    /**
    * 배열인덱스 연산자
    */
 
    int operator[] (int idx ) const {
        if( idx == 0 ) return x;
        else if( idx == 1 ) return y;
        else throw "이럴순 없다";
    }
};
 
int main()
{
    Point p1(10, 20), p2(10, 20);
    Point ret(0,0);
 
//    ret = p1++;
 
    p1.Print();
    ret.Print();
 
    bool bRet = p1 == p2;
    printf("%d\n", bRet);
 
 
    try
    {
        Point(1,2)[3];
    }
    catch(char* pStrexception){
        printf("%s\n", pStrexception);
    }
     
    system("pause");
    return 0;
}

 

 

//스마트 포인터 ->,* 연삱자 오버로딩

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
#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; }
};
class PointPtr
{
    Point *ptr;
public:
    PointPtr(Point *p):ptr(p) { }
    ~PointPtr( )
    {
        delete ptr;
    }
    Point* operator->()const
    {
        return ptr;
    }
    Point& operator*()const
    {
        return *ptr;
    }
};
void main()
{
    Point* p1 = new Point(2,3); //일반 포인터
    PointPtr p2 = new Point(5,5); //스마트 포인터
 
    p1->Print(); //p1->Print() 호출 
    p2->Print(); //p2.operator->()->Print() 호출 
    cout << endl;
 
    (*p1).Print(); //(*p1).Print() 호출
    (*p2).Print(); //p1.operator*().Print() 호출
 
    delete p1;
    //p2의 소멸자에서 Point 동적 객체를 자동 메모리 제거합니다.
}

 

 

 

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
 
/**
* 함수 호출 연산자오버로딩()
*/
 
#include <iostream>
 
 
using namespace std;
 
 
 
class FuncObj{    
public:
    void operator() (int arg) const {
        cout<<"정수 : "<<arg<<endl;        
    }
 
    void operator() (int arg1, int arg2 ) const {
        cout<<"정수 : "<<arg1<<","<<arg2<<endl;
    }
 
    void operator() (int arg1, int arg2, int arg3 ) const {
        cout<<"정수 : "<<arg1<<","<<arg2<<","<<arg3<<endl;
    }
};
 
 
void Print1(int arg){
    cout<<"정수 : "<<arg<<endl;
}
 
 
int main(){
 
    void (*Print2)(int) = Print1;
    FuncObj Print3;
 
    Print1(10);    // 함수호출을 이용한 연산자 오버로딩
    Print2(10); // 함수포인터를 이용한 연산자 오버로딩
    Print3(10); // 함수객체를 이용한 연산자 오버로딩
    FuncObj()(10,20,30); // 임시객체를 이용한 연산자오버로딩된 함수호출
                         // 임시객체는 이문장이 끝이나면 소멸된다.
 
 
    system("pause");
    return 0;
}

 

 

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
/**
* 배열 인덱스 연산자오버로딩
*/
 
#include <iostream>
using namespace std;
 
class Array{
 
    int *arr;
    int size;
    int capacity;
 
public:
    explicit Array(int cap = 1) : arr(NULL), size(0), capacity(cap) {
        arr = new int[capacity];
    }
 
    void Add( int data ){
 
        if( size > capacity)
            throw "오바";
        arr[size++] = data;    
    }
    int Size() const{
        return size;
    }
    int& operator[](int idx){
        return arr[idx];
    }
    int operator[](int idx) const{
        return arr[idx];
    }    
};
 
 
int main(){
 
    Array ar(10);
 
    try{
        ar.Add(10);
    }catch( char * pStrException ){
 
        cout<<pStrException<<endl;
    }    
    try{
        ar.Add(20);
    }catch( char * pStrException ){
 
        cout<<pStrException<<endl;
    }    
    try{
        ar.Add(30);
    }catch( char * pStrException ){
 
        cout<<pStrException<<endl;
    }    
 
    ar[0] = 90;
    const Array &ar2 = ar;
    //ar2[0] = 100;
    
    for( int i = 0; i < ar.Size(); ++i )
        cout<< ar[i] <<endl;
    cout<<ar2[0]<<endl;
 
    system("pause");
    return 0;
}

 

Point operator+(const Point& p );

 

멤버함수로 오버로딩된경우

: p1.operator+( p2 ) ;

 

전역함수로 오버로딩 된경우

: operator+(p1, p2);

저작자표시

'0x0001 > C, C++' 카테고리의 다른 글

[C++] 정적함수포인터, 멤버함수포인터  (0) 2019.02.08
[C++] 템플릿 (함수템플릿, 클래스템플릿)  (0) 2019.02.08
[C++] 가상소멸자  (0) 2019.02.08
[C언어] 10진수를 2진수로  (0) 2019.02.08
[C언어] 최대공약수, 최소공배수  (0) 2019.02.08

+ Recent posts

티스토리툴바