{{ label!='' ? 'Label : ' : (q!='' ? '검색 : ' : '전체 게시글') }} {{ label }} {{ q }} {{ ('('+(pubs|date:'yyyy-MM')+')') }}

[C++] 스터디 CPPALOM 7주차: 뇌를 자극하는 C++ STL Chap 2-3

파워 포인트 파일(.pptx)을 Markdown으로 변환하여 업로드하였음) 

# <br>CPPALOM

# <br>7주차 – 뇌를 자극하는 C++ STL Chap 2-3
한수빈

# <br>함수 포인터

* 함수 포인터는 함수의 시작 주소를 저장하는 포인터이다.
  * 정수형 변수와 포인터 변수의 용례는 다음과 같다:
* 함수 역시 포인터로 주소를 저장할 수 있다.
  * 반환형 (*이름)(인자)
    * void (*pf)(int)

```C++
void main()
{
    int n = 10;
    int *pn = &n;
}
```

```C++
void Print(int n)
{
    cout <<"정수: "<< n << endl;
}
void main()
{
    // void Print(int n)의 함수 포인터 선언
    void (*pf)(int );
    // 함수의 이름은 함수의 시작 주소
    pf=Print;
    Print( 10 ); //1. 함수 호출
    pf( 10 ); //2. 포인터를 이용한 함수 호출, 첫 번째 방법
    (*pf)( 10 ); //3. 포인터를 이용한 함수 호출, 두 번째 방법
    cout << endl;
    cout << Print << endl;
    cout << pf << endl;
    cout << *pf << endl;    
}
```

```C++
정수: 10
정수: 10
정수: 10
00CD1154
00CD1154
00CD1154
```

# <br>함수 포인터의 종류

* C++에서 함수는 정적 함수와 멤버 함수로 나눌 수 있다.
  * 정적 함수로는 전역 함수, namespace 내의 전역 함수, static 멤버 함수가 해당된다.
* 함수 호출은 세 가지가 가능하다.
  * 정적 함수 호출
  * 객체를 이용해 멤버 함수 호출
  * 객체의 주소로 멤버 함수 호출

```C++
void Print( )
{
    cout <<"정적 함수 Print()"<< endl;
}
class Point
{
public:
    void Print( )
    {
        cout <<"멤버 함수 Print()"<< endl;
    }
};
void main()
{
    Point pt;
    Point * p = &pt;
    Print(); // 첫째, 정적 함수 호출
    pt.Print(); // 둘째, 객체로 멤버함수 호출
    p->Print(); // 셋째, 주소로 멤버함수 호출
}
```

```C++
정적 함수 Print()
멤버 함수 Print()
멤버 함수 Print()
```

# <br>정적 함수 호출

```C++
void Print(int n)
{
    cout <<"전역 함수: "<< n << endl;
}
namespace A
{
    void Print(int n)
    {
        cout <<"namespace A 전역 함수: "<< n << endl;
    }
}
class Point
{
public:
    static void Print(int n)
    {
        cout <<"Point 클래스의 정적 멤버 함수: "<< n << endl;
    }
};
void main()
{
    void (*pf)(int );
    Print( 10 ); // 1. namespace 없는 전역 함수 호출
    A::Print( 10 ); // 2, namespace A의 전역 함수 호출
    Point::Print( 10 ); // 3, Point 클래스의 정적 멤버 함수 호출
    cout << endl;
    pf = Print;
    pf( 10 );  // 1. 함수 포인터로 namespace 없는 전역 함수 호출
    pf = A::Print;
    pf( 10 );  // 2. 함수 포인터로 namespace A의 전역 함수 호출
    pf = Point::Print;
    pf( 10 );  // 3. 함수 포인터로 Point 클래스의 정적 멤버 함수 호출
}
```

정적 함수 포인터는 함수 시그너처만 알면 쉽게 선언할 수 있다.

```C++
전역 함수: 10
namespace A 전역 함수: 10
Point 클래스의 정적 멤버 함수: 10
전역 함수: 10
namespace A 전역 함수: 10
Point 클래스의 정적 멤버 함수: 10
```

# <br>멤버 함수 호출

```C++
class Point
{
    int x;
    int y;
public:
    explicit Point(int _x =0, int _y =0 ):x(_x),y(_y) { }
    void Print( ) const { cout << x <<',' << y << endl; }
    void PrintInt(int n) { cout << "테스트 정수 : "<< n << endl; }
};
int main()
{
    Point pt(2,3);
    Point *p = &pt;
    void (Point::*pf1)() const; // 멤버 함수 포인터 선언
    pf1 = &Point::Print;
    void (Point::*pf2)(int ) ; // 멤버 함수 포인터 선언
    pf2 = &Point::PrintInt;
    pt.Print();         
    pt.PrintInt( 10 );
    cout << endl;
    (pt.*pf1)();  // 객체로 멤버 함수 포인터를 이용한 호출
    (pt.*pf2)(10);// 객체로 멤버 함수 포인터를 이용한 호출  
    cout << endl;
    (p->*pf1)();  // 주소로 멤버 함수 포인터를 이용한 호출
    (p->*pf2)(10);// 주소로 멤버 함수 포인터를 이용한 호출
    return 0;
}
```

멤버 함수도 동일하게 호출 가능하나, 객체를 이용해서 호출해야 한다.

```C++
2,3
테스트 정수 : 10
2,3
테스트 정수 : 10
2,3
테스트 정수 : 10
```

* 왜 다음과 같이 멤버 함수 호출을 할 수 없는가?
  * 함수 호출 규약이 다르기 때문이다.
  * 정적 함수는 __cdecl, 멤버 함수는 __thiscall 규약을 사용한다.
* 어셈블리 수준에서 함수의 호출 방식이 다르며, 멤버 함수의 경우 반드시 객체의 주소를 참조할 수 있어야 하기 때문에 함수의 주소만을 갖고 있을 수 없다!
  * 그래서 반드시 객체를 통해서 호출하는 문법만이 가능하다.

```C++
class Point
{
    int x;
    int y;
public:
    explicit Point(int _x =0, int _y =0 ):x(_x),y(_y) { }
    void Print( ) const { cout << x <<',' << y << endl; }
    void PrintInt(int n) { cout << "테스트 정수 : "<< n << endl; }
};
int main()
{
    pf1 = pt.Print;
    (pf1)();
    pf2 = p->PrintInt;
    (pf2)(10);
    return 0;
}
```

# <br>클라이언트 코드와 서버 코드

클라이언트 코드: 사용자

서버 코드: 제공자

클라이언트 코드는 서버 코드를 사용한다.

```C++
#include <iostream>
using namespace std;
//////// 서버 /////////////
void PrintHello( )
{
    cout << "Hello!" << endl;
}
/////// 클라이언트 /////////
void main( )
{
    PrintHello( );
}
```

# <br>콜백 함수

콜백 메커니즘은 더 유용한 추상화를 실현할 수 있게 만든다.

STL의 많은 알고리즘, GUI 프레임워크는 이러한 콜백을 사용한다.

```C++
void Client();
//////// 서버 /////////////
void PrintHello( )
{
    cout << "Hello!" << endl;
    Client(); //서버에서 클라이언트 코드 호출
}
/////// 클라이언트 /////////
void Client( )
{
    cout << "난 client" << endl;
}
void main( )
{
    PrintHello( ); //서버 코드 호출
}
```

# <br>함수 포인터를 이용한 콜백 메커니즘 구현

```C++
//////// 서버 /////////////
// 배열의 모든 원소에 반복적인 작업을 하도록 추상화되어 있음(구체적인 작업은 없음)
void For_each(int *begin, int *end, void (*pf)(int ) )
{
    while( begin != end )
    {
        pf( *begin++ ); // 클라이언트 함수 호출(콜백)
    }
}
/////// 클라이언트 /////////
void Print1(int n) // 공백을 이용하여 원소를 출력
{
    cout << n <<' ';
}
void Print2(int n) // 각 원소를 제곱하여 출력
{
    cout << n*n <<" ";
}
void Print3(int n) // 문자열과 endl을 이용하여 원소를 출력
{
    cout <<"정수 : "<< n <<endl;
}
void main( )
{
    int arr[5] = {10, 20, 30, 40, 50};
    For_each(arr, arr+5, Print1); // Print1() 콜백 함수의 주소를 전달
    cout << endl << endl;
    For_each(arr, arr+5, Print2); // Print2() 콜백 함수의 주소를 전달
    cout << endl << endl;
    For_each(arr, arr+5, Print3); // Print3() 콜백 함수의 주소를 전달
}
```

* 콜백 메커니즘을 사용하기 위해서 함수 포인터를 활용할 수 있다.
  * 그 외에도 함수 객체, 위임(Delegate) 및 전략(Strategy) 패턴을 사용할 수 있다.

```C++
10 20 30 40 50
100 400 900 1600 2500
정수 : 10
정수 : 20
정수 : 30
정수 : 40
정수 : 50
```

# <br>STL의 for_each 사용

* 앞의 예제와 동일한 방식으로 활용되는 것이 있다:
  * for_each
* 콜백 메커니즘을 이용해서 순회 방식만 추상화하고, 내부의 구현은 클라이언트가 수행한다.

```C++
#include <iostream>
#include <algorithm> // for_each() 알고리즘(서버)을 사용하기 위한 헤더
using namespace std;
/////// 클라이언트 /////////
void Print1(int n) // 공백을 이용하여 원소를 출력
{
    cout << n <<' ';
}
void Print2(int n) // 각 원소를 제곱하여 출력
{
    cout << n*n <<" ";
}
void Print3(int n) // 문자열과 endl을 이용하여 원소를 출력
{
    cout <<"정수 : "<< n <<endl;
}
void main( )
{
    int arr[5] = {10,20,30,40,50};
    for_each(arr, arr+5, Print1); // Print1() 콜백 함수의 주소를 전달
    cout << endl << endl;
    for_each(arr, arr+5, Print2); // Print2() 콜백 함수의 주소를 전달
    cout << endl << endl;
    for_each(arr, arr+5, Print3); // Print3() 콜백 함수의 주소를 전달
}
```

```C++
10 20 30 40 50
100 400 900 1600 2500
정수 : 10
정수 : 20
정수 : 30
정수 : 40
정수 : 50
```

# <br>함수 객체

* 함수 객체(Function Object)란 함수처럼 동작하는 객체이다.
  * 함수처럼 동작하기 위해서 () 연산자를 정의해야 한다.
  * 즉, () 연산자를 오버로딩한 객체이다.

```C++
#include <iostream>
using namespace std;
void Print( )
{
    cout << "전역 함수!" << endl;
}
struct Functor
{
    void operator( )( )
    {
        cout << "함수 객체!" << endl;
    }
};
void main( )
{
    Functor functor;
    Print();   // 전역 함수 호출
    functor(); // 멤버 함수 호출 functor.operator()( )와 같다;
}
```

* 매개변수 리스트를 갖는 함수 객체 역시 만들 수 있다.
* 함수 객체의 장점
  * 함수처럼 동작하는 객체이므로 일반 함수에서 하지 못하는 지원을 받을 수 있다.
    * 다른 멤버 변수와 멤버 함수를 가질 수 있다.
  * 함수 포인터는 인라인 될 수 없지만, 함수 객체는 인라인 될 수 있다.

```C++
#include <iostream>
using namespace std;
void Print(int a, int b)
{
    cout << "전역 함수: " << a << ',' << b << endl;
}
struct Functor
{
    void operator( )(int a, int b)
    {
        cout << "함수 객체: " << a << ',' << b << endl;
    }
};
void main( )
{
    Functor functor;
    Print(10, 20);   // 전역 함수 호출
    functor(10, 20); // 멤버 함수 호출 functor.operator()(10, 20)와 같다;
}
```

```C++
전역 함수: 10, 20
함수 객체: 10, 20
```

# <br>멤버 변수를 갖는 함수 객체

Adder 클래스는 멤버 변수를 이용해서 함수가 호출될 때마다 해당 값을 누적한다.

operator()(int n) 함수는 클래스 내부에 정의되므로 암묵적으로 인라인 함수가 된다.

```C++
#include <iostream>
using namespace std;
class Adder
{
    int total;
public:
    explicit Adder(int n=0):total(n) { }        
    int operator( )(int n)
    {
        return total+=n;
    }
};
void main( )
{
    Adder add(0); //초기값 0
    cout << add(10) << endl; //10을 누적=>10
    cout << add(20) << endl; //20을 누적=>30
    cout << add(30) << endl; //30을 누적=>60
}
```

# <br>함수 객체를 사용한 콜백 함수 구현

```C++
/////// 클라이언트 /////////
struct Functor1
{
    void operator()(int n) // 공백을 이용하여 원소를 출력
    {
        cout << n <<' ';
    }
};
struct Functor2
{
    void operator()(int n) // 각 원소를 제곱하여 출력
    {
        cout << n*n <<" ";
    }
};
struct Functor3
{
    void operator()(int n) // 문자열과 endl을 이용하여 원소를 출력
    {
        cout <<"정수 : "<< n <<endl;
    }
};
void main( )
{
    int arr[5] = {10,20,30,40,50};
    for_each(arr, arr+5, Functor1());//임시 함수자 객체(Functor1())를 만들어 함수로 전달
    cout << endl << endl;
    for_each(arr, arr+5, Functor2());//임시 함수자 객체(Functor2())를 만들어 함수로 전달
    cout << endl << endl;
    for_each(arr, arr+5, Functor3());//임시 함수자 객체(Functor3())를 만들어 함수로 전달
}
```

* 결과는 이전과 같으며, for_each() 알고리즘의 세 번째 인자에 함수가 아닌 함수 객체를 전달했다는 점을 주목하라.
  * 이는 템플릿을 응용한 것이며,

```C++
10 20 30 40 50
100 400 900 1600 2500
정수 : 10
정수 : 20
정수 : 30
정수 : 40
정수 : 50
```

# <br>함수 객체 구현

* STL에는 유용하게 사용할 수 있는 함수 객체가 내장되어 있다.
  * 가령, less와 greater.
  * 비교 연산자의 함수 객체이며, bool 형을 반환하는 조건자(predicate)이다.

```C++
#include <iostream>
using namespace std;
bool Pred_less(int a, int b)
{
    return a < b;
}
struct Less
{
    bool operator()(int a, int b)
    {
        return a < b;
    }
};
void main( )
{
    Less l;
    cout << Pred_less(10, 20) << endl;
    cout << Pred_less(20, 10) << endl;
    cout << endl;
    cout << l(10, 20) << endl; // l 객체로 암묵적 함수 호출
    cout << l(20, 10) << endl; // l 객체로 암묵적 함수 호출   
    cout << Less()(10, 20) << endl; // 임시객체로 암묵적 함수 호출   
    cout << Less()(20, 10) << endl; // 임시객체로 암묵적 함수 호출   
    cout << endl;
    cout << l.operator()(10, 20) << endl; // 명시적 호출
    cout << Less().operator()(10, 20) << endl; // 명시적 호출
}
```

```C++
1
0
1
0
1
0
1
1
```

* greater 역시 마찬가지로 활용할 수 있다.
  * 단, STL의 경우 템플릿 클래스이므로 템플릿 매개변수를 명시해주어야 한다.

```C++
#include <iostream>
#include <functional> 
using namespace std;
struct Less
{
    bool operator()(int a, int b)
    {
        return a < b;
    }
};
struct Greater
{
    bool operator()(int a, int b)
    {
        return a > b;
    }
};
void main( )
{
    cout << Less()(10, 20) << endl; //사용자 Less, Greater 사용
    cout << Less()(20, 10) << endl;  
    cout << Greater()(10, 20) << endl;
    cout << Greater()(20, 10) << endl; 
    cout << endl;
    cout << less<int>()(10, 20) << endl; //STL의 less, greater 사용
    cout << less<int>()(20, 10) << endl;  
    cout << greater<int>()(10, 20) << endl;
    cout << greater<int>()(20, 10) << endl; 
}
```

```C++
1
0
1
0
1
0
1
1
```

마지막으로 유용하게 쓸 수 있는 plus와 minus 함수 객체 구현이다.

```C++
#include <iostream>
#include <functional> //Less<> 헤더
using namespace std;
struct Plus
{
    int operator()(int a, int b)
    {
        return a + b;
    }
};
struct Minus
{
    int operator()(int a, int b)
    {
        return a - b;
    }
};
void main( )
{
    cout << Plus()(10, 20) << endl; //사용자 Plus, Minus 사용
    cout << Plus()(20, 10) << endl;  
    cout << Minus()(10, 20) << endl;
    cout << Minus()(20, 10) << endl; 
    cout << endl;
    cout << plus<int>()(10, 20) << endl; //STL의 plus, minus 사용
    cout << plus<int>()(20, 10) << endl;  
    cout << minus<int>()(10, 20) << endl;
    cout << minus<int>()(20, 10) << endl; 
}
```

```C++
30
30
-10
10
30
30
-10
10
```

댓글

댓글 쓰기

이 블로그의 인기 게시물

[코딩의탑] 5층: 포탈(Portal), 더 나아가기

이미지
2층에서 많은 부족함이 있었죠..   2층 에서 우리가 구현한 포탈은 다음과 같은 부족함이 있습니다: 포탈을 단순히 월드에 배치하기만 했으며, 포탈 건의 요구사항을 고려하지 않았습니다. 가령 포탈은 벽에 생성될 수 있어야 합니다. 플레이어의 포탈 이동만을 고려했습니다. 큐브 등 다른 오브젝트 역시 통과할 수 있어야 합니다. 포탈에 걸쳐있는 오브젝트는 포탈 양면에서 보일 수 있어야 합니다. 즉, 오브젝트의 복사가 이루어져야 합니다. Near plane clippng으로 인해 포탈에 들어가기 직전 카메라가 평면과 겹치는 순간, 포탈 평면의 뒷면 모습이 비춰집니다. 포탈에 비추는 플레이어의 모습이 3인칭으로 보여야 합니다. 효율적인 포탈 재귀 렌더링 방법이 필요합니다. 복습해봅시다. 벡터와 점의 변환   포탈 건너편으로 이동하는 효과를 주기 위해서, 우리는 적절히 오브젝트를 이동 및 회전시켜야 합니다. 속도 역시 적절한 방향으로 보존되어야 하죠. 포탈   먼저 위치와 속도는 3차원 벡터로 표현될 수 있습니다. 그리고 이것이 포탈과 포탈 사이에서 자연스럽게 이어져야 하죠. 마치 포탈이 붙어있는 것처럼요! 다음 그림을 참고해보세요. 블루 포탈과 오렌지 포탈은 서로가 위 방향 축을 기준으로 180도 회전한 상태에서 맞붙어있는 것처럼 느껴야 합니다. 블루 포탈과 오렌지 포탈   이는 각 포탈을 일종의 지역 좌표계로 생각해볼 수 있습니다. 포탈의 [앞 방향 벡터, 우측 방향 벡터, 위 방향 벡터]를 각각 [X, Y, Z]축으로 삼는 셈이죠. 우리는 마치 "이어져 있는" 환상을 선사해야 하므로, 한쪽 지역 좌표계의 좌표 값을 그대로 다른쪽 지역 좌표계의 좌표 값으로 자연스럽게 넘겨주면 됩니다. 다양한 방법이 있겠지만 성능을 위해, 각 축에 대한 내적의 값을 이용하도록 합시다. 각 축은 정규화되어 있고 수직이므로, 내적을 이용할 수 있습니다. 좌표계의 변환 소스 코드: APortal::TransformVectorToDestSpace(), Tra...
자세한 내용 보기

[코딩의탑] 4층: 툰 쉐이딩

이미지
가끔은 만화스러운 느낌이 좋을 때도 있죠.   셀 쉐이딩(Cel shading)이라고도 불리는 툰 쉐이딩 기법은 절제된 빛 표현으로 화면을 그리는 비사실적(non-photorealistic) 렌더링 기법 중 하나입니다.  <Borderlands 시리즈>   이러한 툰 쉐이딩은 다양한 방식으로 실현되고 있으며, 언리얼 엔진을 활용한 툰 쉐이딩 역시 어렵지 않습니다. 특히, 포스트 프로세싱을 이용하여 만화스럽게 후처리를 해주는 방법은 클라이언트 프로그래머들이 손쉽게 사용할 수 있는 방법입니다.   하지만, 포스트 프로세싱을 이용한 툰 쉐이딩은 다음과 같은 단점이 존재하는데요: 포스트 프로세싱 자체의 비용이 존재합니다. 특정한 머티리얼에만 툰 쉐이딩을 적용하기 어렵습니다. (커스텀 스텐실 버퍼를 활용하는 것이 대표적인 방법이며, 이는 개발자를 피곤하게 합니다)   따라서, 우리는 포스트 프로세싱을 활용하지 않는 툰 쉐이딩을 구현해보도록 하죠. 우리는 다음을 구현할 것입니다: 특정 물체의 윤곽선을 추가로 렌더링합니다. 특정 물체의 음영을 부드럽지 않은 단계별 음영으로 변경합니다. 이들의 사용 여부와 윤곽선 굵기, 색을 머티리얼 에디터 속성으로 결정할 수 있습니다. 반복되는 컴파일을 줄이기 위해 머티리얼 인스턴스로 만들 수 있으며, 윤곽선의 굵기를 재컴파일 없이 변경할 수 있습니다.   이는  언리얼 엔진 5의 소스를 직접 수정하는 방법임에 주의하세요. 이러한 방법 역시 마법이 아니므로, 비용이 존재합니다. 이는 차차 이야기하도록 하겠습니다. 그 전에 언리얼 엔진 5를 살펴보도록 하죠. 렌더링 패스 디퍼드 쉐이딩으로 렌더링에 필요한 다양한 정보를 담는 버퍼들   언리얼 엔진은 기본적으로 PC 게임에 한해 디퍼드 쉐이딩을 수행합니다. 디퍼드 쉐이딩이란 포워드 쉐이딩의 반대 개념입니다. 한 물체를 렌더링한다고 생각해보죠. 그 물체의 3차원 세계 좌표와 물체 표면의 법선, 표면 거칠기의 정도,...
자세한 내용 보기

[코딩의탑] 3층: 바다 렌더링

이미지
바다를 그려봅시다.   수많은 게임들은 바다를 배경으로 하고 있습니다. 굳이 바다를 게임의 메인 배경으로 하지 않더라도, 게임 어느 중간에는 꼭 바다를 볼 수 있는 순간이 나오기 마련이죠.  <Sea of Thieves>   이러한 바다를 유체역학적 지식으로 구현하는 것은 쉽지 않습니다. 화면에 보이는 입자가 너무 많아 현실적으로 계산 능력이 부족하기 때문입니다. 따라서 많은 게임들은 바다를 구현하기 위해서 수많은 편법을 활용하고 있습니다. 대표적인 방법은 Displacement Mapping(변위 매핑)을 이용하는 것이죠.  Displacement Mapping   Displacement Mapping이란 Displacement Map을 이용해 물체를 구성하는 일련의 정점들을 재배치하는 것을 의미합니다. 가령, 평평한 격자의 물체가 있고 다음과 같은 두 개의 Displacement Map이 있다면 우리는 파도와 같은 현상을 만들어낼 수 있습니다. 하나는 큰 파도(저주파)를, 다른 하나는 작은 파도(고주파)를 재현합니다. 흰색일수록 위에 있으며, 검은색일수록 아래에 있게 됩니다.   이러한 Displacement Map들을 겹친 후에, 서로 다른 방향으로 움직이게 만들고 겹쳐진 값을 이용해서 Displacement Mapping을 한다면 저렴한 연산으로 파도와 같은 환상을 만들어낼 수 있습니다. 하지만 이 방법은 정적으로 파도가 만들어진다는 한계가 있습니다. 바람의 방향, 파도의 세기 등을 조절하기가 어렵죠. 조금 더 멋진 Displacement Map을 만들 수 있는 방법이 있을까요? Jerry Tessendorf의 'Simulating Ocean Water'   영화 프로듀서이자 교수인 Tessendorf는 그럴듯한 바다를 시뮬레이션할 수 있는 방법을 논문으로 정리해 제안하였습니다. 제가 다룰 내용을 간단히 요약하면 다음과 같습니다: 파도는 일종의 사인파와 코사인파의 합입니다. 따라서 ...
자세한 내용 보기