Chapter 8. STL함수-객체

*이 포스팅은 개인 학습을 위해 내용을 정리한 것이 목적입니다.

 

8.1 함수-객체의 개념.

 -함수 객체는 ()연산자를 정의한 객체임.

 -함수객체의 3가지 장점

  1) 함수객체는 상태를 가질 수 있다. 같은 함수 객체에 대해 동시에 다른 상태를 가질 수 있음

  2) 각각의 함수 객체는 자신만의 타입을 가지므로, 함수 객체의 타입을 템플릿의 인자로 제공가능함.

  3) 함수객체는 함수포인터보다 빠르다.

 

 8.1.1 정렬 기준으로서의 함수객체

   특정 클래스에 대해 정렬하여 가지고 있는 컨테이너가 필요할 수 있다. 이 경우 특정 클래스에 특정한 정

  렬 기준을 적용하여 가지고 있으려면 함수 객체를 사용하면 된다.

   예제)

class Person{  private:     string fn;     string ln;  public:     explicit Person(const string& f, const string& l) : fn(f), ln(l) {}     string firstname() const { return fn; }     string lastname() const { return ln; }  };  class PersonSortCrit{  public:     bool operator() (const Person& p1, const Person& p2) const {         return (p1.lastname() < p2.lastname()) || (!(p2.lastname() < p1.lastname()) && p1.firstname() <                  p2.firstname());     }   }; void fo1(){    using namespace MyLib;    typedef set<Person, PersonSortCrit> PS;    PS col;    Person p1( "Hello", "World");    Person p2( "aa", "World");    Person p3( "a", "World4");    Person p4( "a", "World2");    Person p5( "Hello", "ddd");    col.insert(p1);    col.insert(p2);    col.insert(p3);    col.insert(p4);    col.insert(p5);    PS::iterator pos = col.begin();    for( pos = col.begin() ; pos != col.end() ; pos++){       cout << "[" << pos->firstname() << ", " << pos->lastname() << "]" << endl;    } }

    > set은 연관컨테이너여서 알아서 정렬되서 데이터가 들어감.

    > 여기서 정렬 조건을 person에 따라서 정렬되도록 변경

 

 8.1.2 내부 상태를 가지는 함수 객체

   함수 객체는 reference가 아닌 value로 전달된다. 알고리즘에서 함수 객체 내부의 상태를 변경시키지 않

  는다. 만약 내부 상태를 변경하고 싶을 경우에는 레퍼런스로 전달하거나 for_each()알고리즘의 반환 값을

  이용하는 두가지 방법이 있다.

   - 함수 객체를 레퍼런스로 전달하기 위해서는 템플릿의 인자를 명시적으로 선언해야 함.

  예제)

class IntSeq{    private:       int value;    public:       IntSeq(int initVal) : value(initVal){}       int operator() () { return value++; }  }; void istest1(){     list<int> col;    generate_n(back_inserter(col), 9, IntSeq(1)); //col에 데이터 넣어주기 위함    print_elems(col, "first");    generate( ++col.begin(), --col.end(), IntSeq(40)); //col의 데이터 조작을 위해 사용    print_elems(col, "2nd");  }

    > 여기서 함수객체는 IntSeq. 정수 시퀀스를 생성하기 위해 사용되었다.

 

 8.1.3 for_each()의 반환 값

   for_each()는 다른 알고리즘과 다르게 함수객체를 반환한다.

예제)

class MeanValue{  private:     long num;     long sum;  public:     MeanValue() : num(0), sum(0){}     void operator() (int elem){        num++;        sum += elem;     }     operator double(){        return static_cast<double>(sum) / static_cast<double>(num);     }  }; void fetest1(){    vector<int> col;    initCon(col, 1, 8);    MeanValue mv = for_each(col.begin(), col.end(), MeanValue());    cout << "mean value: " << mv << endl; }

   > for_each에서는 계산(MeanValue())을 마친 후, 그 객체를 mv에 할당함. 그래서, mv는 결과를 가지고 있다.

 

 8.1.4 조건자와 함수객체

   조건자는 boolean을 반환하는 함수 또는 함수객체임. 알고리즘의 구현방식이 알고리즘이 동작하는 동안

  조건자들의 내부적인 복사본을 생성한다. 그에 따라 조건자가 함수 객체로 넘어갈 경우 함수객체의 복사본

  을 사용한다.

 예제)

class Nth{  private:     int nth;     int count;  public:     Nth(int n) : nth(n), count(0){}     bool operator() (int) { return ++count==nth; } }; void rif1(){    using namespace MyRIFLib;    list<int> col;    initCon(col, 1,9);    print_elems(col, "col");    list<int>::iterator pos;    pos = remove_if(col.begin(), col.end(), Nth(3));    col.erase(pos, col.end());    print_elems(col, "nth removed"); } 결과 col : 1 2 3 4 5 6 7 8 9 nth removed: 1 2 4 5 7 8 9

    > 3번째 원소가 제거된 것 뿐만 아니라 다음 3번째 (즉, 6번째)원소가 함께 제거되었다. remove_if에서 원소를 찾은 후 남은 원소를 처리하기 위해 조건자의 복사본을 사용한다고 한다. 근데 Nth를 2로 해 보면, 2,4가 제거되어 있다. 원소를 한번 찾아서 제거한 후, 다음 번 원소는 딱 한번만 더 실행되는 이유는?

 

8.2 미리정의된 함수-객체

 *STL에 미리 정의된 함수객체

함수객체명	설명
negate<type>()	- param
plus<type>()	param1 + param2
minus<type>()	param1 - param2
multiplies<type>()	param1 * param2
divides<type>()	param1 / param2
modulus<type>()	param1 % param2
equal_to<type>()	param1 == param2
not_equal_to<type>()	param1 != param2
less<type>()	param1 < param2. 정렬의 기본기준
greater<type>()	param1 > param2
less_equal<type>()	param1 <= param2
greater_equal<type>()	param1 >= param2
logical_not<type>()	!param
logical_and<type>()	param1 && param2
logical_or<type>()	param1 || param2

 

 

 8.2.1 함수 어댑터

  -함수어댑터 : 함수-객체를 특정값 또는 특정 함수와 결합시킨 함수 객체

  -미리 정의된 함수 어댑터

표현식	효과
bind1st(op, value)	op(value, param)
bind2nd(op, value)	op(param, value)
not1(op)	!op(param)
not2(op)	!op(param1, param2)

 

  -기능적 조합법 : 함수 어댑터는 스스로 함수-객체가 됨. 함수 어댑터를 사용하여 다른 함수객체들을 결합할 수 있음

 

 8.2.2 멤버 함수를 위한 함수 어댑터

  -C++ 표준 라이브러리에는 컬렉션의 각각의 원소에 대해 멤버함수를 호출하는 어댑터제공

  -멤버 함수에 대한 함수 어댑터   

표현식	효과
mem_fun_ref(op)	객체에 대해서 멤버함수 op()를 호출
mem_fun(op)	객체의 포인터에 대해 멤버함수 op()를 호출

 

    -mem_fun_ref의 목적 : 각 객체에 대해 멤버함수 호출이 불가하여 해당 어댑터를 사용하여 알고리즘에 멤

  버함수를 전달해주기 위함

 

 8.2.3 기존의 함수를 위한 함수 어댑터

  - 기존 함수를 함수객체와 사용할 수 있도록 해주기 위함

  - 표현식 

표현식	효과
ptr_fun(op)	*op(param)
	*op(param1, param2)

 

 8.2.4 함수어댑터를 위한 사용자 정의 함수-객체

  - 사용자가 정의한 함수 객체를 어댑터와 같이 사용하려면 몇가지 조건을 만족시켜야 함.

    작성한함수 객체들은 함수객체의 인자와 결과를 위해 타입 멤버를 제공하여야 함. 이를 위해 C++표준 라

    이브러리에서는 unary_function, binary_function 구조체를 제공한다. 사용자는 위 구조체를 상속받아 함

    수객체를 만들어 쉽게 어댑터와 함께 동작할 수 있도록 만들 수 있다.

    *구조체 형태

unary function	binary function
template<class Arg, class Result>  struct unary_function{    typedef Arg argument_type;    typedef Result result_type; };	template<class Arg1, class Arg2, class Result>  struct binary_function{     typedef Arg1 first_argument_type;     typedef Arg2 second_argument_type;     typedef Result result_type; }

함수객체정의예제

   예제) 

//fopow.hpp #include <functional> #include <cmath> template <class T1, class T2> struct fopow : public std::binary_function<T1, T2, T1> {     T1 operator() (T1 base, T2 exp) const {        return std::pow(base, exp); //VC6에서는 std::pow가 아닌 pow임     } }

    > binary_function을 상속받았음.

    > 위 struct는 class로 변경해도 동작한다. 단! public선언해 줄것.

 

 예제)

#include "fopow.hpp" using namespace std; void fopowtest() {     vector<int> col;     initCon(col, 1, 9);     transform(col.begin(), col.end(), ostream_iterator<int>(cout, " "), bind1st(fopow<float,int>(),3));     cout << endl;     transform(col.begin(), col.end(), ostream_iterator<int>(cout," "), bind2nd(fopow<float,int>(),3));     cout << endl; }

   > bind1st(func, param), param을 func의 첫번째 인자로 넘긴다.

      bind2nd(func, param) : param을 func의 두번째 인자로 넘겨준다.

 

 

8.3 조립함수-객체

 - 조립함수-객체는 기존의 다른 컴포넌트에서 새로운 컴포넌트를 만들고자 할경우 매우 유용하게 사용할

  수 있다.

 - 유용하게 사용할 수 있는 조립함수-객체들

   i) f(g(elem))

     가장 일반적인 단항 조립함수 형태. 단항 조건자의 중첩 호출을 허용. elem을 사용하는 g의 결과를 f의

    입력으로 사용. 단항 조건자처럼 행동

     예)

    f_g정의

//compose.hpp #include <functional> template <class OP1, class OP2> class compose_f_gx_t : public std::unary_function< typename OP2::argument_type, typename                                                                          OP1::result_type> { private:    OP1 op1;    OP2 op2; public:    compose_f_gx_t(const OP1& o1, const OP2& o2) : op1(o1), op2(o2) {}    typename OP1::result_type;    operator() (const typename OP2::argument_type& x) const {       return op1(op2(x));     } };   template <class OP1, class OP2> inline compose_f_gx_t<OP1, OP2> compose_f_gx(const OP1& o1, const OP2& o2){    return compose_f_gx_t<OP1,OP2>(o1,o2); }

  > op2가 먼저 수행된 후, op1이 수행된다.

   사용

#include " compose.hpp" void compose1() {     vector<int> col;     initCon(col, 1, 9);     print_elems(col, "init");     transform(col.begin(), col.end(), ostream_iterator<int>(cout, " "),     compose_f_gx(bind2nd(multiplies<int>(),5), bind2nd(plus<int>(),10)));     cout << endl; }

 

   ii) f(g(elem1, elem2))

     elem1과 elem2를 이항조건자 g의 인자로 전달하고, 그 결과를 f의 입력으로 사용. 전체 표현식은 이항조

    건자처럼 행동

   iii) f( g(elem), h(elem))

     elem을 두개의 다른 조건자 g(), h()에 전달하고 이 결과를 f의 입력으로 사용. 조립된 함수에 하나의 인

    자를 주입하는 형태. 단항조건자처럼 행동함.

    함수객체정의예제

template <class OP1, class OP2, class OP3> class compose_f_gx_hx_t : public std::unary_function <typename OP2::argument_type, typename OP1::result_type> { private:    OP1 op1;    OP2 op2;    OP3 op3; public:    compose_f_gx_hx_t(const OP1& o1, const OP2& o2, const OP3& o3) : op1(o1), op2(o2), op3(o3) {}    typename OP1::result_type operator() (const typename OP2::argument_type& x) const {      return op1(op2(x), op3(x));    } }; template <class OP1, class OP2, class OP3> inline compose_f_gx_hx_t<OP1, OP2, OP3> compose_f_gx_hx(const OP1& o1, const OP2& o2, const OP3& o3){    return compose_f_gx_hx_t(o1,o2,o3); }

    > 함수 형태 정의만 한다

 

   사용예제

void compose2() {    vector<int> col;    initCon(col, 1, 9);    print_elems(col, "init");    vector<int>::iterator pos;    pos = remove_if(col.begin(), col.end(), /*ostream_iterator<int>(cout, " "),*/    compose_f_gx_hx(logical_and<bool>(),bind2nd(greater<int>(),4), bind2nd(less<int>(),7)));    col.erase(pos, col.end());    cout << endl; }

 

 

   iv) f(g(elem1), h(elem2))

     elem1, elem2를 두개의 다른 조건자 g(), h()에 전달하고 결과를 f의 입력으로사용. 조립된 함수에 인자

    를 분배하는 형태. 이항조건자처럼 행동함.

   hpp정의예제

template <class OP1, class OP2, class OP3> class compose_f_gx_hy_t : public std::unary_function <typename OP2::argument_type, typename OP1::result_type> { private:    OP1 op1;    OP2 op2;    OP3 op3; public:    compose_f_gx_hy_t(const OP1& o1, const OP2& o2, const OP3& o3) : op1(o1), op2(o2), op3(o3) {}    typename OP1::result_type operator() (const typename OP2::argument_type& x, const typename         OP3::argument_type& y) const {       return op1(op2(x), op3(y));    } }; template <class OP1, class OP2, class OP3> inline compose_f_gx_hy_t<OP1, OP2, OP3> compose_f_gx_hy(const OP1& o1, const OP2& o2, const OP3& o3){    return compose_f_gx_hy_t(o1,o2,o3); }

 

 

 

참조 : C++ Standard Library - A tutorial and Reference