| C++ - "*"와 "*&" 차이점 (0) | 2016.12.05 |
|---|---|
| C++ - 1 MilliSecond로 시, 분, 초 만들기 (0) | 2016.11.28 |
| C++ - 생성자에서 멤버 변수 초기화 주의 사항 (0) | 2016.11.23 |
| C++ - CPU 사용율 알아 오는 소스 코드 (0) | 2016.11.22 |
| C++ - 멀티 모니터의 해상도를 가져오기 (0) | 2016.08.24 |
| 구조체나 클래스나 C++에서는 같이 취급됩니다. 다만 default 영역이 구조체는 private 이고 클래스는 public이라는 점만 다를 뿐입니다. 그래서 클래스라고 하면 그것은 union까지도 포함하는 구조체를 포괄하는 개념입니다. 클래스에는 흔히 가상함수가 존재합니다. 하나의 클래스 내에서 가상함수는 상속관계에 의해 그 함수주소가 변해야 하므로 가상함수 테이블 일명 VTable을 유지하고, 클래스 내에서는 이 VTable(Virtual Table)을 가리키는 4바이트 포인트를 가집니다. C++빌더의 경우는 인스턴스를 생성하면 그 인스턴스의 최초 4바이트가 바로 VTable을 가르키는 포인트입니다. VC++의 경우도 마찬가지로 인스턴스의 최초 4바이트가 VTable을 가리키는 포인트입니다. 우선 가상함수가 없는 클래스를 보겠습니다. // 가상함수가 없는 구조체 또는 클래스 class TT1 { public: int t1; int t2; String str; // AnsiString클래스는 문자열을 가르키는 4바이트포인트만을 가지는 클래스로, 처음선언시 0(NULL)으로 초기화된다. 그러므로 문자열 대입전에는 0으로 재설정해도 상관없다. 어차피 0 이므로. TT1() { // 가상함수가 없는 순수 클래스/구조체는 이렇게 한줄로 모두 0으로 간단히 초기화 할수 있다. ZeroMemory(this, sizeof(*this)); } }; 생성자에서 ZeroMemory(this, sizeof(*this)); 로 한방에 멤버변수를 0으로 초기화하는데 아무런 문제가 없습니다. 가상함수가 없는 간단한 클래스는 이런식으로 초기화하는 것은 실무에서도 많이 쓰이는 기법입니다. MS 플머들도 많이 애용하죠. 하지만 멤버함수중에 가상함수가 존재할때 이렇게 초기화하면 인스턴스 첫 4바이트인 VTable을 가리키는 포인트값이 0으로 되어 가상함수는 기능을 하지 못하게 됩니다. 엑세스바이얼레이션 예외를 일으키게 됩니다. 그러므로 가상함수를 포함하고 있을때는 VTable을 가리키는 포인트를 피해서 초기화를 하면 되겠죠. 다음은 가상함수를 포함하는 클래스를 보겠습니다. // 가상함수를 포함하는 클래스/구조체 class TT { public: int temp; virtual ~TT() { } // VTable 0번 virtual void func1() { add("run func1"); } // VTable 1번 virtual void func2() { add("run func2"); } // VTable 2번 virtual void func3(int a) { add(String("run func3 ") + a); } // VTable 3번 TT() { //add(String().sprintf("&t:%08X &t.temp:%08X", this, &temp)); ZeroMemory(&temp, sizeof(*this) - 4); // VTable의 포인트를 피해서. add(temp); } }; 생성자에 VTable을 피해서 초기화하는 기법이 보입니다. 앞 4바이트를 피하겠다고, ZeroMemory(this + 4, sizeof(*this) - 4); 식으로 했다가는 엉뚱한 곳의 메모리를 0으로 채우게 됩니다. this 는 TT 형이므로 this + 4는 곧 this 메모리번저 + 4 * sizoef(TT); 와 같기 때문입니다. 위처럼 첫 멤버변수의 메모리 번지를 취하는 것이 안전합니다. 사이즈에 있어서도 sizeof(*this) - 4 표현보다 sizeof(*this) - ((int)&temp - (int)this) 가 더 낫습니다만, win32 어플인 경우는 바뀌지 않는 사항이기 때문에, 그냥 위처럼 그냥 간편하게 사용해도 됩니다. 위에서는 4개의 가상함수가 쓰였는데, 4개의 함수포인트 배열인 VTable은 클래스에 가상함수가 쓰여진 순서대로 존재하게 됩니다. 그러므로 위에서 0번부터 순서를 붙여놓은 순서대로 VTable이 구성됩니다. 여기서 주의해야할 것은 VTable의 구성방법에 대해서는 C++표준이 정해진바가 없어 컴파일러 제작사마다 구현방법이 틀릴수 있다는 사실입니다. C++빌더와 VC++의 구성방법이 틀리며, 지금 설명하고 있는 내용은 전부 C++빌더 중심적인 설명입니다. 다음은 가상함수를 포함하는 클래스를 합성한 경우입니다. // 가상합수가 있는 클래스를 포함하는 클래스. class TT2 { public: int temp2; int temp3; TT t; // 가상함수가 있는 클래스죠. TT2() { add(String().sprintf("this:%08X temp2:%08X t:%08X t.temp:%08X", this, &temp2, &t, &t.temp)); // 여기서는 ZeroMemory 전체를 초기화해서는 안된다. // 가상테이블이 있는 클래스를 피해서, // 원하는 부분만 한번에 0으로 초기화하는 기법은 아래와 같다. ZeroMemory(&temp2, offsetof(TT2, t) - offsetof(TT2, temp2)); add(String().sprintf("TT2 특정 블럭 크기:%d", offsetof(TT2, t) - offsetof(TT2, temp2))); } virtual ~TT2() { } }; 예제에서 add(...)함수가 자꾸 나오는데 add(...)는 결과를 메모장에 찍어보기 위한 간단함수입니다. 아래와 같습니다. void add(String msg) { Form1->Memo1->Lines->Add(msg); } TT2 클래스의 경우를 보면 TT2의 인스턴스의 첫 4바이트는 TT2에 대한 VTable을 가르킵니다. 안에 포함한 TT의 인스턴스 t 도 VTalbe을 가지고 있는데 마찬가지로 t 의 인스턴스 첫 4바이트가 VTable을 가르킵니다. temp3 변수 다음번지에 t의 인스턴스가 위치하며, t의 인스턴스 첫 4바이트는 TT의 VTable을 가르킨다는 것입니다. 그러면 TT2 클래스를 한방에 초기화 할수 있는 방법은 없을까요? 당연히 t 가 VTable에 대한 포인트를 포함하고 있으므로 t 인스턴스를 피해서 초기화를 해야 합니다. 즉 temp2 변수부터 t 바로 위인 temp3 까지만 0으로 초기화 하면 되죠. ZeroMemory(&temp2, offsetof(TT2, t) - offsetof(TT2, temp2)); offsetof를 이용한 한번에 초기화하는 기법입니다. temp2부터 t 인스턴스 이전 까지의 크기를 구하는 기법이 보이는데, int 변수가 2개이므로 짐작한대로 8바이트의 크기가 됩니다. 지금까지 VTable과 한방에 멤버변수를 0으로 만드는 기법을 설명했는데, 정확하게 알지 못한다면 그냥 초기화 리스트 즉 생성자에서 일일이 멤버변수에 값을 할당하는 기법으로 초기화하시기 바랍니다. 그것이 보다 좋은 프로그래밍 습관입니다. 여기서의 설명은 C++의 구현된 내부구조를 살펴보는데 목적이 있습니다. VTable과 VTable에 대한 포인트의 성질을 이용해서 다음과 같은 실험을 해 볼수 있습니다. typedef void (*Tfunc)(void *pClass); typedef void (*Tfunc3)(void *pClass, int a); void __fastcall TForm1::Button4Click(TObject *Sender) { TT t; int *pClass = (int *)&t; void **pVTable = (void **)(*pClass); Tfunc *func = (Tfunc *)pVTable; add(String().sprintf("VTable:%08X", &func)); func[1](pClass); func[2](pClass); Tfunc3 func3 = (Tfunc3)func[3]; func3(pClass, 4); add(""); TT2 t2; } //--------------------------------------------------------------------------- TT 클래스는 4개의 가상함수를 가지는 클래스입니다. 그러므로 그 인스턴스의 번지를 받으면 곧 그 클래스에 대한 포인트가 되죠. 그 포인트의 첫 4바이트는 VTable에 대한 포인트이므로 그 값을 받아서 VTable를 함수포인트배열로 인식시킵니다. void **pVTable = (void **)(*pClass); 이렇게 되면 pVTable[0] => ~TT() pVTable[1] => func1() pVTable[2] => func2() pVTable[3] => func3(int a) 를 가르키게 됩니다. 하지만 pVTable은 함수포인트의 포인트가 아닌 void * 형으로 선언되어 있으므로, 함수포인트로 캐스팅을 해 줍니다. Tfunc *func = (Tfunc *)pVTable; Tfunc3 func3 = (Tfunc3)func[3]; 그리고 원하는 가상함수를 호출할 수 있습니다. func[1](pClass); func[2](pClass); func3(pClass, 4); 인자로 꼭 pClass를 붙인 이유는 모든 클래스의 멤버함수는 그 첫 인자로 자신의 인스턴스의 주소 값을 가져야 하기 때문입니다. 그래야, 그 값을 가지고 인스턴스의 멤버변수를 엑세스 할수있을 테닌까요. 물론, func1, func2 멤버 함수처럼 인자가 없고, 안에서 멤버변수를 엑세스하지 않는다면 pClass 가 아닌 NULL을 넘기거나 아예 인자 없이 호출해도 됩니다. 이 경우 스택의 인자를 호출 받은 함수에서 제거하는 파스칼식 호출 규약이 아니어야 겠죠. //--------------------------------------------------------------------------- 이상 간략한 설명을 했는데 프로그램할때 거의 신경을 안쓰는 사항이기는 해도, 아무래도 고급기법을 구사하려면 내부 구조를 아는 것이 좋습니다. 어차피 COM을 제대로 이해하려면 VTable 에 대한 지식은 필수입니다. 멤버 변수 초기화 기법은 그냥 참고적으로 이해해도 좋은데, 제가 프로그램할 때는 사실 자주 이용하는 기법이기도 합니다. 그림도 없이 설명해서 미안한데, 다음에 기회되면 보충하죠. 출처 : http://cbuilder.borlandforum.com/impboard/impboard.dll?action=read&db=bcb_tutorial&no=97 |
| C++ - 1 MilliSecond로 시, 분, 초 만들기 (0) | 2016.11.28 |
|---|---|
| C++ - Mutex를 이용하여 프로그램을 한번만 실행하기 (0) | 2016.11.25 |
| C++ - CPU 사용율 알아 오는 소스 코드 (0) | 2016.11.22 |
| C++ - 멀티 모니터의 해상도를 가져오기 (0) | 2016.08.24 |
| C++ - Intel CPU에서의 최적화 (0) | 2016.07.04 |
이 소스코드는 MinGW 32/64bit 모두에서 동작을 하는 CPU 사용을 확인을 위한 C++ 소스 코드 입니다. cpuu.h 와 cpuu.cpp 파일 내에 CPUUages 라는 Class 가 정의 되어 있으며, 이 Class 에서 CPU 사용율을 얻어 올 수 있도록 만들어 져 있습니다.
이미 많은 부분들에서 이 방법들을 사용하고 있긴 합니다만, MinGW 에서는 제대로 동작하거나 빌드 되지 않아서 이 부분을 다시 재정의 하여 만들었습니다.
CPU 가 평균 특정 Percentage 이하로 내려 가야 동작하게 한다거나, 반대로 특정 사용율 이상 일때 뭔가 하도록 하는 방법을 찾으신다면 첨부된 소스를 참조 해 보시기 바랍니다.
별거 아닌 소스 이기 때문에 별다른 정보를 기재 하지는 않겠습니다.
| C++ - Mutex를 이용하여 프로그램을 한번만 실행하기 (0) | 2016.11.25 |
|---|---|
| C++ - 생성자에서 멤버 변수 초기화 주의 사항 (0) | 2016.11.23 |
| C++ - 멀티 모니터의 해상도를 가져오기 (0) | 2016.08.24 |
| C++ - Intel CPU에서의 최적화 (0) | 2016.07.04 |
| C++ - 함수 포인터와 함수자 - 5 (0) | 2016.04.18 |
보통 해상도 구하는건 이걸 사용하죠.
int iWidth = GetSystemMetrics(SM_CXSCREEN);
int iHeight = GetSystemMetrics(SM_CYSCREEN);
그런데, 이건 주 모니터의 해상도 밖에 못 구합니다.
아래 걸 사용하면 다중 모니터를 고려한 최대 해상도를 구해 옵니다.
int iWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
int iHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
[출처] 멀티 모니터 해상도 구하기|작성자 핵이
각 모니터 위치나 세세한 정보도 얻어 올 수 있습니다.
| C++ - 생성자에서 멤버 변수 초기화 주의 사항 (0) | 2016.11.23 |
|---|---|
| C++ - CPU 사용율 알아 오는 소스 코드 (0) | 2016.11.22 |
| C++ - Intel CPU에서의 최적화 (0) | 2016.07.04 |
| C++ - 함수 포인터와 함수자 - 5 (0) | 2016.04.18 |
| C++ - 함수 포인터와 함수자 - 4 (0) | 2016.04.18 |
프로그래밍을 최적화 하는데에는 크게 2개의 방법이 있다.
1. Memory Access를 줄여라. (Cache를 이용하여 해결 가능)
2. 분기(if)를 줄여라. (예측 분기를 이용하여 해결 가능)
Cache를 하는 기준은 다음과 같다.
1. 시간성. (가져온지 얼마 안된 데이터)
2. 공간성. (가져온 데이터의 근처에 있는 데이터)
for(x = 0; ; )
{
for(y = 0; ;)
{
// 다음과 같은 2중 for문일 때에는 공간성을 위해 가로로 돌게하는 것이 성능에 도움이 된다.
}
}
for()
{
// L1 레지스트리가 32k이고, 하이퍼 스레드의 경우 16k씩 2개가 돌게 된다.
// if 없이 16k이하의 크기만 돌게 작성해야 한다. Cache보다 데이터가 크다면 Cache가 아예 동작을 하지 않는다.
// if가 7개 이상 있으면 예측 분기가 불가능 하다.
}
출처 : 회사 세미나 중에서...
| C++ - CPU 사용율 알아 오는 소스 코드 (0) | 2016.11.22 |
|---|---|
| C++ - 멀티 모니터의 해상도를 가져오기 (0) | 2016.08.24 |
| C++ - 함수 포인터와 함수자 - 5 (0) | 2016.04.18 |
| C++ - 함수 포인터와 함수자 - 4 (0) | 2016.04.18 |
| C++ - 함수 포인터와 함수자 - 3 (0) | 2016.04.18 |
오늘은 술어 구문(predicate)와 어댑터(not1(), not2(), bind1st(), bind2st())를 공부하겠습니다.
이 페이지를 공부하려면 기초적인 STL을 알아야 합니다.
술어 구문(predicate)이란 bool형을 반환하는 함수류입니다. 즉, 비교 함수입니다.
함수 역할을 하는 함수자(functor)도 operator()가 bool형을 반환하면 술어 구문이겠죠?
대표적인 술어 구문 클래스가 less와 greater 클래스입니다.
less와 greater 클래스는 사용자 정의가 가능한 술어 구문 함수자 클래스입니다.
술어 구문 함수 예제입니다.
cpumeter.zip#include <functional>
using namespace std;
bool LessPredicate(int left, int right)
{
return left < right;
}
void main( )
{
cout << LessPredicate(10, 20) << endl;
cout << LessPredicate(10, 10) << endl;
cout << LessPredicate(20, 10) << endl;
}
LessPredicate()함수는 bool을 반환하므로 술어 구문(predicate)입니다. 쉽죠~~잉!
less와 greater를 공부해 볼까요?
#include <functional>
using namespace std;
void main( )
{
less<int> lessPred; // 함수 < 와 같은 기능
cout << lessPred( 10, 20 ) << endl;
cout << lessPred( 10, 10 ) << endl;
cout << lessPred( 20, 10 ) << endl<<endl;
greater<int> greaterPred; // 함수 > 와 같은 기능
cout << greaterPred( 10, 20 ) << endl;
cout << greaterPred( 10, 10 ) << endl;
cout << greaterPred( 20, 10 ) << endl<<endl;
less_equal<int> less_ePred; // 함수 <= 와 같은 기능
cout << less_ePred( 10, 20 ) << endl;
cout << less_ePred( 10, 10 ) << endl;
cout << less_ePred( 20, 10 ) << endl<<endl;
greater_equal<int> greater_ePred; // 함수 >= 와 같은 기능
cout << greater_ePred( 10, 20 ) << endl;
cout << greater_ePred( 10, 10 ) << endl;
cout << greater_ePred( 20, 10 ) << endl<<endl;
}
bool operator( T , T ) 멤버 함수를 갖는 함수자 클래스입니다.
보통 임시객체를 만들어 사용합니다.
#include <functional>
using namespace std;
void main( )
{
cout << less<int>()( 10, 20 ) << endl;
cout << greater<int>()( 20, 10 ) << endl;
}
객체 단독으로 사용되는 경우가 없으므로 이 예제처럼 임시 객체를 만들어 바로 사용합니다.
less와 greater의 실제 사용 예를 보겠습니다.
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
void Print(const vector<int>& v)
{
vector<int>::const_iterator iter;
for(iter = v.begin() ; iter != v.end() ; iter++)
cout << *iter <<' ';
cout << endl;
}
void main()
{
vector<int> v(10);
int i;
for(i = 0 ; i < (int)v.size() ; i++ )
v[i] = rand() % 1000;
Print( v );
sort(v.begin(), v.end(), less<int>()); // less<int>() 생략가능
Print( v );
sort(v.begin(), v.end(), greater<int>());
Print( v );
}
첫 번째 결과는 정렬 전입니다.
두 번째 결과는 less predicate를 사용한 정렬입니다.
세 번째 결과는 greater predicate를 사용한 정렬입니다.
연관 컨테이너 set, map은 디폴트로 less를 사용하여 내부 트리를 유지합니다.
간단한 예제를 보겠습니다.
#include <map>
#include <algorithm>
#include <functional>
using namespace std;
void main( )
{
map<int, double > lessMap; // less<int> 생략
map<int, double, greater<int> > greaterMap;
lessMap.insert(pair<int,double>(10,1.5) );
lessMap.insert(pair<int,double>(40,4.5) );
lessMap.insert(pair<int,double>(50,5.5) );
lessMap.insert(pair<int,double>(30,3.5) );
lessMap.insert(pair<int,double>(20,2.5) );
greaterMap.insert(pair<int,double>(10,1.5) );
greaterMap.insert(pair<int,double>(40,4.5) );
greaterMap.insert(pair<int,double>(50,5.5) );
greaterMap.insert(pair<int,double>(30,3.5) );
greaterMap.insert(pair<int,double>(20,2.5) );
map<int , double, less<int> >::iterator iter;
for(iter = lessMap.begin() ; iter != lessMap.end() ; iter++)
cout << iter->first << ',' << iter->second << endl;
cout << "==============" << endl;
map<int , double, greater<int> >::iterator giter;
for(giter = greaterMap.begin() ; giter != greaterMap.end() ; giter++)
cout << giter->first << ',' << giter->second << endl;
}
map에 less와 greater를 사용했을 때 내부적으로 정렬된 출력결과를 보여줍니다. inorder 출력 결과를 볼 수 있습니다.
less는 오름차순으로 왼쪽에 작은 값을 오른쪽에 큰 값을 위치시키고 greater는 반대입니다.
이제 less와 greater를 직접 만들어 볼까요?
#include <map>
#include <algorithm>
#include <functional>
using namespace std;
template <typename T>
struct Less
{
bool operator ( ) (const T& left, const T& right)
{
return left < right;
}
};
template <typename T>
struct Greater
{
bool operator ( ) (const T& left, const T& right)
{
return left > right;
}
};
void main( )
{
Less<int> lessPred; // 함수 < 와 같은 기능
cout << lessPred( 10, 20 ) << endl;
cout << lessPred( 10, 10 ) << endl;
cout << lessPred( 20, 10 ) << endl<<endl;
Greater<int> greaterPred; // 함수 > 와 같은 기능
cout << greaterPred( 10, 20 ) << endl;
cout << greaterPred( 10, 10 ) << endl;
cout << greaterPred( 20, 10 ) << endl<<endl;
}
직접 만들어 사용한 예제입니다. 결과는 less, greater와 동일합니다.
대표적인 어댑터가 not1(), not2(), bind1st(), bind2nd()입니다.
bind1st(), bind2nd()등은 바인더라고도 합니다.
어댑터는 함수자 predicate를 다른 형태의 predicate로 변환하는 일을 합니다.
Boost 쪽에는 STL처럼 복잡하지 않고 어댑터 기능을 간단하고 강력하게 지원합니다.
각 어댑터의 사용 예제부터 보겠습니다.
bind1st()의 예제입니다.
이 어댑터는 두 인자를 받는 predicate를 하나의 인자를 받는 predicate로 변환합니다.
또, 왼쪽 인자를 고정시키고 오른쪽 인자를 매개 변수로 취하는 predicate를 반환합니다.
#include <iostream>#include <functional>using namespace std;void main(){ binder1st< less<int> > binder = bind1st(less<int>(), 10 );
// binder는 어댑터(bind1st() )에 의해 변환된 predicate입니다. cout << binder(5) <<':'<< less<int>()(10, 5) << endl; // 두 문장이 동일합니다. cout << binder(10) <<':'<< less<int>()(10, 10) << endl;// 두 문장이 동일합니다. cout << binder(20) <<':'<< less<int>()(10, 20) << endl;// 두 문장이 동일합니다. cout << "=====위와 같음=====" << endl; cout << bind1st(less<int>(), 10 )(5) <<':'<< less<int>()(10, 5) << endl;// 같다. cout << bind1st(less<int>(), 10 )(10) <<':'<< less<int>()(10, 10) << endl;// 같다. cout << bind1st(less<int>(), 10 )(20) <<':'<< less<int>()(10, 20) << endl;// 같다. }
bind1st()의 왼쪽 인자는 변환하기 위한 predicate이며 오른쪽 인자는 변환후 고정시킬 왼쪽에 값입니다.
이제 bind2nd() 예제를 보도록 하겠습니다.
bind1st()와 동일한 역할을 합니다.
다른 점은 오른쪽 인자를 고정하고 왼쪽 인자를 매개 변수로 취하는 predicate를 반환합니다.
#include <functional>
using namespace std;
void main()
{
binder2nd< less<int> > binder = bind2nd(less<int>(), 10 );
cout << binder(5) <<':'<< less<int>()( 5, 10) << endl; // 두 문장이 동일합니다.
cout << binder(10) <<':'<< less<int>()(10, 10) << endl;// 두 문장이 동일합니다.
cout << binder(20) <<':'<< less<int>()(20, 10) << endl;// 두 문장이 동일합니다.
cout << "==========" << endl;
cout << bind2nd(less<int>(), 10 )(5) <<':'<< less<int>()(5, 10) << endl;// 같다.
cout << bind2nd(less<int>(), 10 )(10) <<':'<< less<int>()(10, 10) << endl;// 같다.
cout << bind2nd(less<int>(), 10 )(20) <<':'<< less<int>()(20, 10) << endl;// 같다.
}
쉽죠~~잉! ㅡㅡ;
not1()과 not2()는 bind1st()나 bind2nd로 변환한 predicate를 NOT하는 역할을 하는 어댑터입니다.
예제를 보도록 하겠습니다.
#include <functional>
using namespace std;
void main( )
{
binder2nd< less<int> > binder = bind2nd(less<int>(), 10 );
unary_negate< binder2nd<less<int> > > unegate = not1(binder);
cout << unegate(5) <<':'<< not1(binder)(5) <<':'<< not1( bind2nd(less<int>(), 10) )(5) << endl; //모두 같다.
cout << unegate(10) <<':'<< not1(binder)(10) <<':'<< not1( bind2nd(less<int>(), 10) )(10) << endl;//모두 같다.
cout << unegate(20) <<':'<< not1(binder)(20) <<':'<< not1( bind2nd(less<int>(), 10) )(20) << endl;//모두 같다.
}
단지, 한 인자를 매개 변수로 받는 predicate를 NOT 하는 predicate를 반환합니다.
아래 예제는 MSDN의 예제코드입니다. 참고하세요.
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std;
int main()
{
vector<int> v1;
vector<int>::iterator Iter;
int i;
for (i = 0; i <= 7; i++) {
v1.push_back(5 * i);
}
cout << "The vector v1 = ( ";
for (Iter = v1.begin(); Iter != v1.end(); Iter++)
cout << *Iter << " ";
cout << ")" << endl;
vector<int>::iterator::difference_type result1;
// Count the elements greater than 10
result1 = count_if(v1.begin(), v1.end(), bind2nd(greater<int>(), 10));
cout << "The number of elements in v1 greater than 10 is: "
<< result1 << "." << endl;
vector<int>::iterator::difference_type result2;
// Use the negator to count the elements less than or equal to 10
result2 = count_if(v1.begin(), v1.end(),
not1(bind2nd(greater<int>(), 10)));
cout << "The number of elements in v1 not greater than 10 is: "
<< result2 << "." << endl;
}
아~! 성의 없죠? ㅡㅡ;;
네 어댑터가 모두 비슷비슷하므로 하나만 구현해 보도록 하겠습니다.
이제 마지막으로 bind1st()함수와 비슷한 함수를 만들어 보도록 하겠습니다.
실제 bind1st()는 몇 가지 멤버를 더 가지고 있지만, 주요 코드는 아래 예제와 같습니다.
#include <functional>
using namespace std;
template<typename PredType,typename ArgType>
class Binder1st
{
//... 다른 정보를 표현하기 위한 멤버....
PredType pred;
ArgType left;
public:
Binder1st(const PredType& _pred,const ArgType& _left):pred(_pred),left(_left) { }
bool operator() ( const ArgType& right )
{
return left < right;
}
};
template<typename PredType,typename ArgType>
Binder1st< PredType,ArgType > Bind1st(const PredType& pred, const ArgType& left)
{
return Binder1st<PredType,ArgType>( pred, left );
}
void main( )
{
Binder1st< less<int>, int > binder = Bind1st(less<int>(), 10 );
cout << binder(5) <<':'<< less<int>()(10, 5) << endl; // 두 문장이 동일합니다.
cout << binder(10) <<':'<< less<int>()(10, 10) << endl;// 두 문장이 동일합니다.
cout << binder(20) <<':'<< less<int>()(10, 20) << endl;// 두 문장이 동일합니다.
cout << "==========" << endl;
cout << Bind1st(less<int>(), 10 )(5) <<':'<< less<int>()(10, 5) << endl;// 같다.
cout << Bind1st(less<int>(), 10 )(10) <<':'<< less<int>()(10, 10) << endl;// 같다.
cout << Bind1st(less<int>(), 10 )(20) <<':'<< less<int>()(10, 20) << endl;// 같다.
}
Bind1st()라는 함수는 왼쪽 인자를 고정시키고 오른쪽 인자를 매개변수로 취하는 함수자 클래스(Binder1st) 객체를 반환합니다. 이 Binder1st 객체가 변환된 predicate입니다.
| C++ - 멀티 모니터의 해상도를 가져오기 (0) | 2016.08.24 |
|---|---|
| C++ - Intel CPU에서의 최적화 (0) | 2016.07.04 |
| C++ - 함수 포인터와 함수자 - 4 (0) | 2016.04.18 |
| C++ - 함수 포인터와 함수자 - 3 (0) | 2016.04.18 |
| C++ - 함수 포인터와 함수자 - 2 (0) | 2016.04.15 |
이번 시간에는 지금까지 배운 내용을 종합하여 STL의 ptr_fun(), mem_fun(), mem_fun_ref()를 직접 구현해 보도록 하겠습니다.
이 세 함수는 함수자를 요구하는 알고리즘에 일반적인 함수들을 실행가능하도록 랩핑하는 함수들입니다.
이 페이지는 '함수 포인터와 함수자1,2,3'를 공부하고 보시기 바랍니다.
앞쪽에서 함수 포인터는 호출형태에 따라 세 가지로 나뉜다고 했습니다.(앞쪽 참고)
이 세가지 경우처럼 어댑터 역할을 하는 랩핑함수 ptr_fun(), mem_fun(), mem_fun_ref()도 그래서 세 가지입니다.
첫 번째 경우인 ptr_fun()함수를 사용한 예제입니다.
for_each()로 콜백하는 코드를 예제로 사용합니다.
{
cout << "int : " << n << endl;
return true;
}
void main()
{
vector<int> v(10);
int i;
for(i = 0 ; i < (int)v.size() ; i++ )
v[i] = i+1;
for_each(v.begin(), v.end(), Print );
cout << "=================" << endl;
for_each(v.begin(), v.end(), ptr_fun(Print) );
}
내용은 어렵지 않지만, for_each()에 ptr_fun()을 사용한 이유가 궁금할 수 있습니다. 위 코드에는 굳이 ptr_fun()이 없어도 되지만 다른 어댑터 함수와 같이 사용하는 경우에(not1()등) 꼭 필요합니다. 간단한 설명은 ptr_fun()에서 사용하는 함수자 클래스의 typedef인 argument_type과 result_type을 사용하기 위해서 입니다. 자세한 내용은 STL에서 공부하고 지금은 ptr_fun()구현 사항에 집중하도록 하겠습니다.
이제 위와 같은 ptr_fun()과 비슷한 함수 Ptr_fun()을 만들어 보도록 하겠습니다.
//////////////////// server ///////////////////// 클래스 : ptr_fun() 함수의 함수자 클래스// 여러가지 기능을 추가로 제공하기 위한 클래스. typedef argument_type, result_type 등....class Ptr_fun_class{ bool (*pf)(int );public : Ptr_fun_class(bool (*_pf)(int ) ):pf(_pf) { } bool operator()(int n ) { return pf(n); }};// 함수 : 함수자를 반환하는 ptr_fun() 함수Ptr_fun_class Ptr_fun( bool (*pf)(int ) ){ return Ptr_fun_class(pf); }
/////////// client /////////////////// bool Print( int n ){ cout << "int : " << n << endl; return true;}void main(){ vector<int> v(10); int i; for(i = 0 ; i < (int)v.size() ; i++ ) v[i] = i+1; for_each(v.begin(), v.end(), Ptr_fun(Print) );}
Ptr_fun_class 클래스는 정적함수의 주소를 저장하는 함수자 클래스입니다.
Print함수는 어댑터 기능을 하는 Ptr_fun()함수에 래핑되어 함수가 반환하는 Ptr_func_class의 함수자 객체를 for_each()에 전달합니다.
for_each()는 그 함수자를 호출합니다.(for_each()는 '함수 포인터와 함수자3'를 참고하세요)
다음은 모든 자료형이 가능하도록 템플릿 클래스로 수정한 예제입니다.
//////////////////// server ///////////////////// 클래스 : ptr_fun()의 함수자 클래스// 여러가지 기능을 제공할 수 있습니다. typedef argument_type, result_type 등....template<typename RType, typename AType>class Ptr_fun_class{ RType (*pf)( AType );public : Ptr_fun_class( RType (*_pf)( AType ) ):pf(_pf) { } RType operator()( AType n ) { return pf(n); }};// 함수 : 함수자를 반환하는 ptr_fun() 함수template <typename RType, typename AType> Ptr_fun_class<RType, AType> Ptr_fun( RType (*pf)(AType) ){ return Ptr_fun_class<RType, AType>(pf);}
/////////// client ///////////////////bool Print( int n ){ cout << "int : " << n << endl; return true;}void main(){ vector<int> v(10); int i; for(i = 0 ; i < (int)v.size() ; i++ ) v[i] = i+1; for_each(v.begin(), v.end(), Ptr_fun(Print) );}
내용은 같습니다.
두 번째 경우인 mem_fun()를 사용한 예제입니다.
for_each()로 Point의 맴버함수 Print()를 콜백하는 예제입니다.
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
class Point
{
int x, y;
public:
Point(int _x = 0, int _y = 0) : x(_x), y(_y) { }
void Print( )
{
cout << "(" << x << "," << y << ")" << endl;
}
};
void main()
{
vector<Point*> v(10);
int i;
for(i = 0 ; i < (int)v.size() ; i++ )
v[i] = new Point(i+1, i+1);
//for_each(v.begin(), v.end(), &Point::Print ); 에러~~~
for_each(v.begin(), v.end(), mem_fun(&Point::Print) );
// delete 생략
}
컨테이너 v는 Point의 주소들을 저장하고 있습니다.
for_each()는 Point의 멤버 함수 Print()를 호출할 수 없습니다. 이유는?? 우리가 앞쪽에서 공부했듯이 정적함수와 멤버 함수 호출방식(인터페이스)이 다르기 때문입니다. 그래서 호출방식을 통일 시키기위한 함수자(어댑터 객체)가 필요하고 mem_fun()이 멤버 함수를 호출가능하도록 함수자 객체를 생성하여 반환하는 것입니다.
이제 우리도 mem_fun()과 비슷한 함수 Mem_fun()을 만들어 보도록 하겠습니다.
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
//////////////////// server ///////////////////
// 클래스 : mem_fun()의 함수자 클래스
// 여러가지 기능을 제공할 수 있습니다. typedef argument_type, result_type 등....
class Point;
class Mem_fun_class
{
bool (Point::*pf)();
public :
Mem_fun_class( bool (Point::*_pf)() ):pf(_pf) {}
bool operator()( Point* p )
{
return (p->*pf)();
}
};
// 함수 : 함수자를 반환하는 mem_fun() 함수
Mem_fun_class Mem_fun( bool (Point::*pf) () )
{
return Mem_fun_class( pf );
}
/////////// client ///////////////////
class Point
{
int x, y;
public:
Point(int _x = 0, int _y = 0) : x(_x), y(_y) { }
bool Print( )
{
cout << "(" << x << "," << y << ")" << endl;
return true;
}
};
void main()
{
vector<Point*> v(10);
int i;
for(i = 0 ; i < (int)v.size() ; i++ )
v[i] = new Point(i+1, i+1);
for_each(v.begin(), v.end(), Mem_fun(&Point::Print) );
cout << "=============" << endl;
Mem_fun_class functor(&Point::Print);
for_each(v.begin(), v.end(), functor );
// delete 생략
}
Mem_fun()함수는 Mem_fun_class의 객체(함수자)를 반환합니다. for_each()는 이 함수자를 이용하여 정적함수(일반함수)와 동일한 인터페이스로 Point::Print 멤버 함수를 호출합니다.
아래는 모든 자료형이 가능하도록 템플릿으로 변환한 예제입니다.
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
//////////////////// server ///////////////////
// 클래스 : mem_fun()의 함수자 클래스
// 여러가지 기능을 제공할 수 있습니다. typedef argument_type, result_type 등....
class Point;
template <typename RType, typename CType>
class Mem_fun_class
{
RType (CType::*pf)();
public :
Mem_fun_class( RType (CType::*_pf)() ):pf(_pf) {}
RType operator()( CType* p )
{
return (p->*pf)();
}
};
// 함수 : 함수자를 반환하는 mem_fun() 함수
template <typename RType, typename CType>
Mem_fun_class<RType, CType> Mem_fun( RType (CType::*pf) () )
{
return Mem_fun_class<RType,CType>( pf );
}
/////////// client ///////////////////
class Point
{
int x, y;
public:
Point(int _x = 0, int _y = 0) : x(_x), y(_y) { }
bool Print( )
{
cout << "(" << x << "," << y << ")" << endl;
return true;
}
};
void main()
{
vector<Point*> v(10);
int i;
for(i = 0 ; i < (int)v.size() ; i++ )
v[i] = new Point(i+1, i+1);
for_each(v.begin(), v.end(), Mem_fun(&Point::Print) );
cout << "=============" << endl;
Mem_fun_class<bool, Point> functor(&Point::Print);
for_each(v.begin(), v.end(), functor );
// delete 생략
}
내용은 위 예제와 같습니다.
마지막으로 세 번째 경우인 mem_fun_ref()를 보도록 하겠습니다.
mem_fun()과 비슷합니다. 차이점은 컨테이너 v가 Point 주소가 아닌 Point 객체를 저장한다는 것입니다. for_each()로 Point의 맴버함수 Print()를 콜백하는 예제입니다.
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
class Point
{
int x, y;
public:
Point(int _x = 0, int _y = 0) : x(_x), y(_y) { }
void Print( )
{
cout << "(" << x << "," << y << ")" << endl;
}
};
void main()
{
vector<Point> v(10);
int i;
for(i = 0 ; i < (int)v.size() ; i++ )
v[i] = Point(i+1, i+1);
//for_each(v.begin(), v.end(), &Point::Print ); 에러~~~~
for_each(v.begin(), v.end(), mem_fun_ref(&Point::Print) );
// delete 생략
}
컨테이너 v가 Point객체를 저장합니다. 내용은 모두 동일합니다.
다음은 mem_fun_ref()과 비슷한 함수 Mem_fun_ref()을 만들어 본 예제입니다.
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
//////////////////// server ///////////////////
// 클래스 : mem_fun()의 함수자 클래스
// 여러가지 기능을 제공할 수 있습니다. typedef argument_type, result_type 등....
class Point;
template <typename RType, typename CType>
class Mem_fun_ref_class
{
RType (CType::*pf)();
public :
Mem_fun_ref_class( RType (CType::*_pf)() ):pf(_pf) {}
RType operator()( CType& d )
{
return (d.*pf)();
}
};
// 함수 : 함수자를 반환하는 mem_fun() 함수
template <typename RType, typename CType>
Mem_fun_ref_class<RType, CType> Mem_fun_ref( RType (CType::*pf) () )
{
return Mem_fun_ref_class<RType, CType>( pf );
}
/////////// client ///////////////////
class Point
{
int x, y;
public:
Point(int _x = 0, int _y = 0) : x(_x), y(_y) { }
bool Print( )
{
cout << "(" << x << "," << y << ")" << endl;
return true;
}
};
void main()
{
vector<Point> v(10);
int i;
for(i = 0 ; i < (int)v.size() ; i++ )
v[i] = Point(i+1, i+1);
for_each(v.begin(), v.end(), Mem_fun_ref(&Point::Print) );
cout << "=============" << endl;
Mem_fun_ref_class<bool, Point> functor(&Point::Print);
for_each(v.begin(), v.end(), functor );
// delete 생략
}
| C++ - Intel CPU에서의 최적화 (0) | 2016.07.04 |
|---|---|
| C++ - 함수 포인터와 함수자 - 5 (0) | 2016.04.18 |
| C++ - 함수 포인터와 함수자 - 3 (0) | 2016.04.18 |
| C++ - 함수 포인터와 함수자 - 2 (0) | 2016.04.15 |
| C++ - 함수 포인터와 함수자 - 1 (0) | 2016.04.04 |
'함수 포인터와 함수자' 세 번째 시간으로 이번에는 '콜백'에 대한 이야기를 해보도록 하겠습니다.
이 페이지는 함수 포인터, STL 기초를 알고 있어야 합니다.
콜백(callback)은 서버가 클라이언트를 호출하는 것을 말합니다.
보통 함수 호출은 클라이언트에서 서버를 호출하는 형태입니다. 하지만 때때로 서버가 클라이언트를 호출해야 하는 경우가 있습니다.
콜백메커니즘을 이용하면 알고리즘 정책을 클라이언트에서 유연하게 바꿀 수 있습니다. 또 GUI의 강력한 이벤트 기능도 콜백메커니즘으로 구현됩니다.
STL의 많은 알고리즘도 콜백을 이용하여 클라이언트 정책을 반영합니다.
윈도우즈(Windows)의 모든 프로시저(procedure)는 시스템이 호출하는 '콜백 함수'입니다. 중요하게 느껴지죠?
예를 들어 보겠습니다.
어떤 기능이나 서비스를 제공하는 코드 측을 서버라고 합니다.
그 기능을 제공 받는 코드 측을 클라이어트라 합니다.
{
printf("Hello!\n");
}
void main( )
{
func();
func();
func();
}main()함수 쪽이 클라이언트이고 func()쪽이 서버라면 main()쪽이 호출자(caller)가 되고 func()쪽이 호출받는자(callee)가 됩니다.
그림으로 보면 아래와 같습니다.
이때, 아래와 같이 클라이언트 코드와 서버 코드가 있을 때 서버 측에서 클라이언트 측 코드인 client()함수를 호출해야 한다면 서버 측에서 client()함수는 콜백되는 것입니다.
using namespace std;
void client( );
//////// server //////////////////////
void func( )
{
printf("Hello!\n");
client( ); //클라이언트 코드 호출
}
//////// client //////////////////////
void client( )
{
printf("난 client!\n");
}
void main( )
{
func(); //서버 코드 호출
}
main()함수 쪽이 클라이언트이고 func()쪽이 서버라면 client함수 호출쪽이 caller가 되고 client()함수 쪽이 callee가 됩니다.
아래 그림을 참고하세요.
콜백은 서버 측에서 클라이언트 측의 코드를 호출하므로 클라이언트 측 함수를 알아야 합니다.
위 예제는 예를 들기 위함으로 client()라는 함수를 server가 알고 있다는 가정하에 만든 것입니다.
하지만 실제 서버는 여러 클라이언트에 의해 호출되므로 미리 클라이언트 코드를 알지 못합니다.
그래서 콜백을 구현하기 위해서는 클라이언트에서 서버에게 콜백으로 사용될 함수의 정보를 알려주고 서버가 클라이언트를 호출하도록 합니다.
이제 실예로 STL코드를 보도록 하겠습니다.
STL 알고리즘의 for_each()을 예로 들겠습니다. for_each() 많이 쓰시죠?
for_each()는 반복자를 이용하여 컨테이너에 들어 있는 모든 요소를 반복적으로 처리하는 함수입니다.
이때 Print1(),Print2()가 콜백 함수입니다.
#include <iostream>#include <vector>#include <algorithm>using namespace std;void Print1( int n ){ cout << "int : " << n << endl;}
void Print2( int n ){ cout << "int : " << n << endl;}void main(){ vector<int> v(10); int i; for(i = 0 ; i < (int)v.size() ; i++ ) v[i] = i+1; for_each(v.begin(), v.end(), Print1);
cout << "=================" << endl;
for_each(v.begin(), v.end(), Print2);}
for_each()는 클라이언트 Print1(),Print2()함수를 콜백하며 클라이언트 기능을 유연하게 바꿔가며 호출합니다.
아래 그림을 참고하세요.
함수뿐만 아니라 함수류는 모두 가능합니다.
Functor를 사용한 예제입니다.
#include <vector>
#include <algorithm>
using namespace std;
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class CallbackClass
{
public:
void operator() (int n)
{
cout << "int : " << n << endl;
}
};
void main()
{
vector<int> v(10);
int i;
for(i = 0 ; i < (int)v.size() ; i++ )
v[i] = i+1;
for_each(v.begin(), v.end(), CallbackClass() );
cout << "=================" << endl;
CallbackClass callback;
for_each(v.begin(), v.end(), callback);
}
함수자 클래스(CallbackClass)를 만들어 사용한 예제일 뿐 나머지는 같습니다.
아래는 그림입니다.
이제 for_each()과 비슷한 알고리즘을 만들어 보도록 하겠습니다.
for_each()는 반복자를 이용하여 모든 컨테이너 요소를 지정한 함수류로 반복(콜백)합니다.
아래는 예제 코드입니다.
#include <vector>
#include <algorithm>
using namespace std;
/////////////// server //////////////////////
template<typename IterT, typename FunT>
void For_each(IterT biter, IterT eiter, FunT fun)
{
for( ; biter != eiter ; biter++ )
fun( *biter );
}
/////////////// client /////////////////////
class CallbackClass
{
public:
void operator() (int n)
{
cout << "클래스 : " << n << endl;
}
};
void Print( int n )
{
cout << "함수 : " << n << endl;
}
void main()
{
vector<int> v(10);
int i;
for(i = 0 ; i < v.size() ; i++ )
v[i] = i+1;
For_each(v.begin(), v.end(), Print);
cout << "=================" << endl;
For_each(v.begin(), v.end(), CallbackClass() );
}
For_each()는 모든 컨테이너와 다양한 함수에 적용해야 하므로 템플릿 함수로 만들어 집니다.
아래는 그림입니다.
| C++ - 함수 포인터와 함수자 - 5 (0) | 2016.04.18 |
|---|---|
| C++ - 함수 포인터와 함수자 - 4 (0) | 2016.04.18 |
| C++ - 함수 포인터와 함수자 - 2 (0) | 2016.04.15 |
| C++ - 함수 포인터와 함수자 - 1 (0) | 2016.04.04 |
| C++ - void 포인터, 함수 포인터 (1) | 2016.04.04 |
