http://cmlife.blogspot.com/2007_02_01_archive.html

auto_ptr

 http://blog.naver.com/uleena?Redirect=Log&logNo=80042072372

#include <iostream>

#include <string>

#include <functional>

using namespace std;

#include <ctime>

#include <bitset>

// unique 한랜덤을만들어내는함수객체

template<int MAX> class URandom

{

        bitset<MAX> bs;

        bool recycle;

public:

        URandom(bool b = false) : recycle(b)

        {

               srand(time(0)); // 난수초기화

               bs.set();       // 모든비트를1로

        }

        int operator()()

        {

               if ( bs.none() )   // 모두0인경우

               {

                       if ( recycle == false) // 재사용안하는경우

                              return -1;

                       else

                              bs.set();  // 모두1로

               }

               int n = -1;

               while ( !bs.test( n = (rand() % MAX) ));

               bs.reset(n);

               return n;

        }

};

int main()

{

        URandom<5> r;

        for ( int i = 0; i < 15;++i)

               cout << r() << endl;

}

// 3. bitset : 비트의집합

#include <bitset>

int main()

{

        bitset<10> bs;

        bs.reset(); // 모두0

        // 각비트를조작하는법

        bs.set(4);

        bs[5] = true;

        bs[6].flip();

        // 비트조사

        if ( bs.test(4) ) cout << "비트4가set" << endl;

        if ( bs[5]      ) cout << "비트5가set" << endl;

        unsigned long n = bs.to_ulong();

        cout << n << endl;

        string s = bs.to_string();

        cout << s << endl;

}

// 2. set : 순서를가지고요소를저장한다. (대부분의STL구현물은RB-Tree사용)

#include <set>

int main()

{

        typedef set<int, greater<int>> SET;

        //set< int, greater<int> > s;

        SET s;

        s.insert(10);

        s.insert( 5);

        s.insert(15);

        s.insert(30);

        s.insert(4);

        pair< SET::iterator, bool> ret = s.insert(10); // 중복? 허용될까?

        if ( ret.second == false )

               cout << "이미요소가있습니다." << endl;

        ostream_iterator<int> os(cout, " ");

        copy( s.begin(), s.end(), os);

}

// 1. pair의개념

template<typename T1, typename T2> struct pair

{

        T1 first;

        T2 second;

        pair(T1 a = T1(), T2 b = T2() ) :first(a), second(b) {}

};

pair<int, int> foo()

{

        // 이안에서2개의값을리턴해주고싶다.

}

int main()

{

        // TR1(또는boost)에는pair에개선된버전인tuple이있다.

        tuple<> none;

        tuple<int> one;

        tuple<int, int> two;

        tuple<int, int, int> three;

        tuple<int, int, int, int> n;

        pair<int, pair<int, int>> p2;

        pair<int, double> p1(1,3.4);

        cout << p1.second << endl; // ?

}

typename 을 써야 하는 순간

http://blog.naver.com/spinx85?Redirect=Log&logNo=140112304004

http://dev.log.mumbi.net/497

STL / 컨테이너

http://blog.naver.com/infopub?Redirect=Log&logNo=100024418644

http://blog.daum.net/coolprogramming/90

 1, 함수자

operator() 연산자를 중복하고 있는 클래스의 객체를 함수 객체( function object) 혹은 함수자(functor)라 합니다.

그래서 함수자는 함수처럼 사용할 수 있습니다.

함수자는 02. C++, STL QS2의 함수 포인터와 함수자를 참고하세요.

아래는 간단한 세가지 함수류(함수, 함수 포인터, 함수자)를 사용한 예제 코드입니다.

1 함수, 2 함수 포인터, 3 함수자를 사용한  두 정수의 합 예제입니다.

1. 30
   30
   30

 위 예제를 보면 함수, 함수 포인터, 함수자의 인터페이스는 모두 같다는 것을 알 수 있습니다.

함수자를 사용하면 아래와 같은 장점이 있습니다.

• 컴파일 시에 함수자를 알고리즘의 인자로 전달할 수 있다.
• 함수 호출을 인라인(inline)화해서 효율성을 향상시킬 수 있다.
• 함수자의 정보를 캡슐화하여 지역화(locally)할 수 있다.

 2, STL 함수자

STL 함수자는 크게 두 가지로 나눌 수 있습니다.

• 1, 일반 함수자 : 특정 기능을 수행하는 함수자.

  • 산술 연산 함수자 : 산술 연산 기능을 수행.
  • 비교 연산 함수자 : 비교 연산 기능을 수행.

  • 논리 연산 함수자 : 논리 연산 기능을 수행.

     

• 2, 함수 어댑터 : 함수류(함수와, 함수 포인터, 함수자)를 인자로 받아 새로운 함수자를 생성.

  • 바인더(binder) : 이항 함수자를 단항 함수자로 변환하는 함수자.
  • 부정자(negator) : 조건자(predicate)를 반대로 변환하는 함수자.
  • 함수 포인터 어댑터(adaptors for pointersto functions) : 함수 포인터를 라이브러리가 필요로 하는 함수자로 변환하는 함수자
  • 멤버 함수 포인터 어댑터(adaptors for pointers to member functions) : 멤버 함수 포인터를 라이브러리가 필요로 하는 함수자로 변환하는 함수자

어댑터의 인자로 사용되는 함수자는 아래 요구 사항을 지켜야 합니다.

• 단항 함수자는 반드시 argument_type, result_type이 정의되어 있어야 한다. 각각은 함수의 인자 타입과 리턴 타입이다.
• 이항 함수자는 반드시 first_argument_type, second_argument_type, result_type이 정의되어 있어야 한다. 각각은 함수의 첫번째 인자 타입과 두 번째 인자 타입, 리턴 타입이다.

어댑터들은 인자로 받는 함수자의 위 정의 타입을 이용하여 컴파일 시간에 타입들을 검사합니다.

이러한 타입 정의를 쉽게하기 위해 STL은 기본 클래스 unary_function과 binary_function을 제공한다. 그래서 위 타입들을 직접 작성할 필요는 없습니다. 어댑터는 무조건 위 기본 클래스를 상속받아 만들면 됩니다. ㅡㅡ;

또 함수류(함수, 함수 포인터, 함수자) 중에서 bool형을 리턴하는(비교에 사용되는) 함수자를 predicate(조건자, 술어 구문)라 합니다.

2.1, 일반 함수자

일반 함수자에는 산술 연산, 비교 연산, 논리 연산 등을 수행하는 함수자들이 있습니다.

2.1.1, 산술 연산 함수자

 산술 연산자에는 plus, minus, multiplies, divides, modulus, negate가 있습니다. 모두 템플릿입니다.

plus의 간단한 예제입니다.

1. 30
   30

두 인자를 받아 합을 리턴하는 함수자입니다.

그렇다면 이런 함수자를 어디에 써먹나? ㅡㅡ;;

STL은 함수자없이는 동작할 수 없을 정도로 많은 곳에 함수자가 사용됩니다. 

plus 함수자를 사용하는 실제 예제를 보도록 하겠습니다.

plus 함수자를 사용한 trasform 알고리즘입니다.

1. 10 20 30
1 2 3
11 22 33


 v1.begin()~v1.end()까지의 원소와 v2의 원소를 함수자(plus<int>())로 연산하여 리턴 결과를 다시 v1.begin()부터 순서대로 저장하는 예제입니다.

그림으로 보면 아래와 같습니다.

STL plus를 사용하지 않고 사용자 Plus 함수자를 만들어 보도록 하겠습니다.

직접 작성한 Plus 함수자 예제입니다.

1. 10 20 30
   1 2 3
   11 22 33

 결과는 같습니다. 직접 작성한 Plus 함수자를 사용했습니다.

STL의 plus처럼 어떤 타입의 합도 계산할 수 있도록 일반화 시키려면 템플릿 클래스로 만들면 됩니다.

다음은 Plus를 템플릿 클래스로 바꾼 예제입니다.

1. 10 20 30
   1 2 3
   11 22 33

단순히 템플릿 클래스로 변환한 것 외에 다른 것은 없습니다.

마지막으로 2, STL 함수자에서 언급했던 것처럼 만약 위에서 작성한 Plus<> 함수자 클래스를 어댑터 적용이 가능하도록 하려면 이항 함수자이므로 first_argument_type, second_argument_type, result_type을 정의해야 합니다. 가장 간단하게 정의할 수 있는 방법은 binary_function 기본 클래스를 상속받는 것입니다. 위 정의 타입이 필요한 이유는 어댑터에서 컴파일 시간에 타입 검사를 할때 위 정의 타입이 필요하기 때문입니다.

어댑터에 자세한 내용은 아래쪽에서 공부합니다.

다음은 binary_function을 상속받은 Plus<> 함수자 클래스입니다.

1. 10 20 30
   1 2 3
   11 22 33

지금 예제에는 어댑터를 사용하지 않기 때문에 굳이 필요하지는 않지만 다음을 위해서 어댑터 적용이 가능하도록 미리 binary_function을 상속받았습니다.

간단한 예제를 보이도록 하겠습니다.(binder1st<> 어댑터 사용)

1. 10 20 30
   110 120 130

v.begin()~v.end()까지의 모든 원소를 네 번째 함수자의 인자로 전달하고 리턴한 결과를 다시 v.begin()부터 순서대로 저장합니다.

 binder1st<>는 이항 연산자를 단항 연산자로 바꾸는 바인더 어댑터입니다. 위 예제의 transform이 단항 연산자를 필요로 하기때문에 이항 연산이 가능한 plus 함수자를 오른쪽 항을 100으로 고정시키고 왼쪽항만 인자로 받을 수 있는 단항 연산자 함수자로 변환합니다.

어댑터는 아래쪽에서 다시 자세히 공부합니다. 지금은 위와 같은 어댑터에 사용하는 plus 함수자는 binary_function 기본 클래스를 상속받아야 한다는 것에 집중하시면 됩니다.

우리가 만든 Plus<>가 binary_function을 상속받지 않으면 무시무시한(?) 에러가 발생합니다.

1. error C2039: 'second_argument_type' : 'Plus<T>'의 멤버가 아닙니다.
   1>        with
   1>        [
   1>            T=int
   1>        ]
   1>        c:\...\main.cpp(28) : 컴파일 중인 클래스 템플릿 인스턴스화 'std::binder1st<_Fn2>'에 대한 참조를 확인하십시오.
   1>        with
   1>        [
   1>            _Fn2=Plus<int>
   1>        ]
2. ....

무서버~!

binary_function 기본 클래스를 상속받으면 쉽게 해결됩니다.

1. 10 20 30
   110 120 130

 간단합니다.

우리가 직접 first_argument_type, second_argument_type, result_type을 정의해도 해결됩니다.

1. 10 20 30
   110 120 130

상속이라는 더 깔끔한 방법이 있으니 binary_function을 상속받는 것이 더 좋겠죠?

minus, multiplies, divides, modulus, negate함수자는 plus와 모두 비슷하므로 생략합니다.

2.1.2, 비교 연산 함수자

 비교 연산자는 equal_to, not_equal_to, greater, less, greater_equal, less_equal이 있습니다. 모두 템플릿 클래스입니다.

 비교 연산 함수자는 모두 predicate입니다. predicate(조건자)는 비교를 수행하는(bool형을 리턴하는 ) 함수류(함수, 함수 포인터, 함수자)을 말합니다.

greater의 간단한 예제입니다.

1. 0
   0
   true

 greater는 두 인자를 받아 첫 번째 인자가 크면 true를 아니면 false를 리턴합니다.

 실제 사용 예제입니다.(sort 알고리즘)

1. 50 20 40 30 10
   10 20 30 40 50
   50 40 30 20 10

 sort는 less를 사용하여 오름차순 정렬을 수행하지만 세 번째 인자로 greater를 전달하면 내림차순 정렬을 합니다.

 다음은 직접 작성한 Greater<>입니다.( 어댑터 적용이 가능하도록 binary_function을 상속 받았습니다.)

1. 50 20 40 30 10
   10 20 30 40 50
   50 40 30 20 10

결과는 같습니다.

나머지 비교 연산 equal_to, not_equal_to, less, greater_equal, less_equal은 greater와 비슷하므로 생략합니다.

2.1.3, 논리 연산 함수자

 논리 연산은  logical_and, logical_or, logical_not가 있습니다.

logical_and의 간단한 예제입니다.(논리 AND 연산을 수행하는 함수자)

1. 1
   0
   true

 두 인자를 입력받아 두 인자 모두 true이면 true를 리턴하고 아니면 false를 리턴합니다. AND 연산!

간단한 사용 예제입니다.

1. false  false  true

 간단하죠?

너머지는 모두 비슷하므로 생략합니다.

 오늘은 여기까지입니다. ^^

...

#include <iostream>
#include <list>
#include <functional>
#include <algorithm>

using namespace std;

class fuctor{

public :
 int m_MemData;
 static int m_data;

public :
 fuctor(int ini) {
  m_MemData = ini;
 }
 fuctor() {
  m_MemData = m_data++;
 }
 int operator+( int data ) const{
  return this->m_MemData + data;
 }
 void show(int data){
  cout<<m_MemData + data<<"\t";
 }

};

int fuctor::m_data = 1;

class IntSequence{

public :
 fuctor operator()(){
  return fuctor();
 }

};

template<typename T1,typename T2>
class plus1 : public binary_function<T1,T2,T1>{
public :
 T1 operator()(const T1 lhs,const T2 rhs) const {
  return  T1(lhs + rhs);
 }
};

int main(){

 list<fuctor> coll2;
 
 generate_n( back_inserter(coll2),10,  IntSequence() );

 transform(coll2.begin(),coll2.end(),coll2.begin(), bind2nd( plus1<fuctor,int>(),10 ) );

 for_each( coll2.begin(),coll2.end(), bind2nd(mem_fun_ref(&fuctor::show) ,100)  );
 
 if(getchar())
  return 0;
}

emplate<typename OP1,typename OP2>
class compose_f_gx_t : public unary_function< typename OP2::argument_type,typename OP1::result_type>
{

private :
 OP1 op1; // op(op2(x)) 를 처리한다
 OP2 op2;
public :
 compose_f_gx_t(const OP1& o1, const OP2& o2) : op1(o1), op2(o2)
 {

 }
 typename OP2::result_type
  operator()(const typename OP2::argument_type& x) const {
   return op1(op2(x));
 }

};

template<typename OP1,typename 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);
}

#include <memory>
#include <vector>
#include <list>
#include <Windows.h>
#include <string.h>
#include<iostream>
#include <algorithm>

using namespace std;

 return 0;
}

C++의 STL 표준 라이브러리는 미리 정의된 여러가지 함수 객체들을 제공한다.

이러한 표준 함수객체들을 사용하기 위해서는 #include <functional> 을 포함해야 한다.

이 함수객체들은 알고리즘의 비교,정렬을 위한 기준으로 사용될 수 있다.

less<> 는 알고리즘에서 디폴트 기준으로 사용되는 오름차순 정렬이다.

1. 함수어댑터

함수어댑터란, 함수객체를 특정값 또는 특정함수와 결합시킨 함수객체이다.

이러한 함수어댑터 역시 <functional> 에 정의되어 있다.

find_if(coll.begin(), coll.end(), bind2nd(greater<int>(), 42));

이 코드에서 bind2nd(greater<int>(), 42) 는 정수타입 변수가 42보다 큰지를 판단하는 결합된 함수객체를 생성한다.

bind2nd는 greater<> 와 같은 이항 함수객체를 단항 함수객체로 변형시킨다.

즉, bind2nd의 두번째 인자를 이항 함수객체의 두번째 인자로 사용하는 것이다.

따라서, greater<>는 42를 두번째 인자로 하여 호출한다.

함수어댑터는 스스로가 함수객체이다. 따라서, 함수어댑터를 함수객체와 결합하여 사용할 수 있다.

pos=find_if(coll.begin(), coll.end(), not1(bind2nd(modulus<int>(), 2)));

이 코드에서 bind2nd(modulus<int>(), 2) 는 모든 홀수에 대해 1(참) 을 반환한다.

따라서, 이 표현식은 홀수값을 갖는 첫번째 원소를찾는 기준이된다.

하지만 not1() 은 이 결과를 반전시키므로, 짝수값을 갖는 첫번째 원소의 위치를 반환한다.

2. 멤버함수를 위한 함수어댑터

이것은 STL 컨테이너의 각각의 원소들에 대해서 멤버함수를 호출시켜주는 함수 어댑터이다.

#include <iostream>
#include <vector>
#include <functional>
using namespace std;

class person{
 private:
  string name;
 public:
  person(char *nm):name(nm){}
  void print()const{
   cout<<name<<endl;
  }
  void printWithPrefix(string prefix)const{
   cout<<prefix<<name<<endl;
  }
};

int main(){
 vector<person> coll;
 coll.push_back(person("AAAA"));
 coll.push_back(person("BBBB"));
 coll.push_back(person("CCCC"));
 coll.push_back(person("DDDD"));

 //각각의 원소에 대해서 멤버함수 print()를 호출
 for_each(coll.begin(), coll.end(), mem_fun_ref(&person::print));
 
 //각각의 원소에 대해서 멤버함수 printWithPrefix()를 호출
 //"person : " 은 멤버함수 printWithPrefix() 의 인자로 전달
 for_each(coll.begin(), coll.end(), bind2nd(mem_fun_ref(&person::printWithPrefix), "person : "));
}

3. 일반 함수들을 위한 함수어댑터

ptr_fun() 은 기존의 일반 함수들을 함수객체와 같은 형태로 사용하도록 하는 함수객체 어댑터이다.

예를들어, 각각의 인자에 대해 무언가를 검사하는 일반 전역함수를 가지고 있을때

bool check(int elem);

이러한 경우 조건을 만족하는 첫번째 원소를 찾으려면 다음과 같이 호출한다.

pos=find_if(coll.begin(), coll.end(), ptr_fun(check));

조건을 만족하지않는 첫번째 원소를 찾으려면 다음과 같이 사용할 수 있다.

pos=find_if(coll.begin(), coll.end(), not1(ptr_fun(check)));

사용자가 두개의 인자를 사용하는 전역함수를 가지고 있다고 가정한다면

pos=find_if(coll.begin(), coll.end(), not1(bind2nd(ptr_fun(strcmp), "AAA")));

strcmp는 두개의 string이 같을경우 false를 반환한다.

따라서, 이 구문은 "AAA" 와 같은 첫번째 string의 위치를 반환한다.