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
 
#include <iostream>
using namespace std;
 
 
/**
*    함수객체
*/
 
void Print(){
    cout<<"전역함수!"<<endl;
}
 
class Functor{
public:
    void operator() (){
        cout<<"함수객체!"<<endl;
    }
};
 
// 함수객체란
// 함수처럼 동작하는 객체, 함수처럼 동작하려면
// ()연산자를 정의해야합니다. 
// 다시말해 ()연산자를 오버로딩한 객체입니다.
// 함수객체는 함수자(Functor)라고 불리기도 합니다.
 
int main()
{
    Functor functor;
 
    Print();    //전역함수 호출
    functor();    //멤버함수호출 functor.operator()와 같다
 
    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
 
/**
*    함수객체를 사용한 콜백함수 구현
*/
 
#include <iostream>
#include <algorithm>
 
using namespace std;
 
class Functor1{ //출력
public:
    void operator()(int n){
        cout<<n<<endl;
    }
};
 
class Functor2{ //제곱
public:
    void operator()(int n){
        cout<<n*n<<endl;
    }
};
 
int main ()
{
    int arr[5] ={ 1, 2, 3, 4, 5 };
    for_each(arr, arr+5, Functor1() );
    // 임시 함수객체 Functor1을 만들어 함수로 전달
    // for_each알고리즘은 함수객체 사용자정의 타입까지도 전달받을수있다.
    // 여기서보면 전달되는 함수객체 타입이 다른데(1, 2)
    // 어떻게 그럴수 있을까? 정답은 템플릿이다.
 
    cout<<endl;
    for_each(arr, arr+5, Functor2() );
    
    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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
#include <iostream>
#include <functional>
 
using namespace std;
 
/**
*    함수객체구현및 STL함수객체(less,greater, plus,minus)
*/
 
class Less{
public:
    bool operator()(int n1, int n2){
        return n1 < n2 ? true : false;
    }
};
 
class Greater{
public:
    bool operator()(int n1, int n2){
        return n1 > n2 ? true : false;
    }
};
 
class Plus{
public:
    int operator()(int n1, int n2){
        return n1+n2;
    }
};
 
class Minus{
public:
    int operator()(int n1, int n2){
        return n1-n2;
    }
};
 
 
typedef less<int> stl_less;
typedef greater<int> stl_greater;
typedef plus<int> stl_plus;
typedef minus<int> stl_minus;
 
int main()
{
    Less l;
    stl_less l2;
 
    Greater g;
    stl_greater g2;
 
    Plus p;
    stl_plus p2;
 
    Minus m;
    stl_minus m2;
 
    cout<< Less()(10,20) <<endl;        // 임시객체로 암묵적 함수호출
    cout<< l.operator()(20,10)<<endl;    // l1객체로 명시적 함수호출
    cout<< stl_less()(10, 20) <<endl;    // stl less 임시함수객체로 암묵적 함수호출
    cout<< l2.operator ()(20, 10)<<endl;// stl less l2 함수객체로 명시적 함수호출
    cout<<endl;
 
    cout<< Greater()(10, 20) <<endl;
    cout<< g.operator()(20, 10) <<endl;
    cout<< stl_greater()(10, 20) <<endl;
    cout<< g2.operator ()(20, 10)<<endl;
    cout<<endl;
 
    cout<< Plus()(10, 20) <<endl;
    cout<< p.operator()(20,10) <<endl;
    cout<< stl_plus()(10, 20)<<endl;
    cout<< p2.operator ()(20, 10) <<endl;
    cout<<endl;
 
    cout<< Minus()(10, 20) <<endl;
    cout<< m.operator()(20, 10) <<endl;
    cout<< stl_minus()(10, 20) <<endl;
    cout<< m2.operator ()(20, 10)<<endl;
 
    system("pause");
    return 0;
}
 
 
 


+ Recent posts