리눅스는 유저 모드와 커널 모드 두개의 실행영역을 가진다. 유저 모드는 일반 응용 프로그램이 실행되는 영역이고, 커널 모드는 커널(:12) 명령이 실행되는 영역이다. 하드웨어에 대한 모든 제어는 커널 모드에서 이루어진다. 두개의 모드로 나눈 이유는 다중 사용자 / 다중 프로세스 운영체제에서 자원에 대한 관리와 보안 을 위함이다.

응용 프로그램은 커널 모드에 진입을 할 수 없으므로 하드웨어에 대한 접근을 할 수 없다. 이는 메모리 할당, 파일 읽기/쓰기와 같은 주요한 작업을 할 수 없음을 의미한다. 하지만 이래서는 제대로 된 응용 프로그램을 만들 수 없 을 것이다.

리눅스 커널은 "간접 접근 방식"으로 이 문제를 해결 한다. 직접 하드웨어에 접근하는 대신 커널에게 자원의 사용을 요청을 하고, 커널이 자원의 사용을 허락하는 방식이다.

이때 커널이 응용 프로그램에 제공하는 함수가 시스템콜이다.

http://www.joinc.co.kr/w/man/12/%EC%8B%9C%EC%8A%A4%ED%85%9C%EC%BD%9C

커널모드란??

커널모드를 검색하다가 이해가 안되던 도중 pdf 파일을 하나 발견하고 내용이 쉽게 이해되 바로 설명하며 포스팅을 써보았습니다.

일단 커널모드란?

리눅스 커널은 프로그램을 실행할 때 크게 두 가지의 모드에서 실행을 한다. 커널 모드 (kernel mode)와 사용자 모드(user mode)가 그것인데, 이 두 모드에 대해서 간단히 설명 을 하자면 커널 모드에서의 프로그램들은 직접적인 하드웨어 요청이나 중요한 시스템 요 청을 할 때 사용되는 모드이다. 일반적으로 사용자가 직접적으로 하드웨어 장치를 사용한 다면 큰 문제가 발생할 수도 있는 데 이것을 방지하기 위해서 커널 모드로 프로그램이 실 행되면서 하드웨어 제어를 커널에서만 할 수 있도록 한 것이다. 원래 사용자가 어느 한 프로그램을 실행하면 사용자 모드에서 실행이 되다가 그 프로그 램이 하드웨어 장치를 사용해야 할 경우 사용자 모드에서 실행되고 있던 프로그램이 커널 모드로 제어권이 넘어가서 하드웨어 장치를 사용하게 된다. 하드웨어 장치를 다 사용하게 되면 다시 프로그램은 사용자 모드로 다시 제어권이 넘어가서 나머지 프로그램을 실행하 게 된다.

설명이 쉽게 나와있는데 이걸로 이해가 안된다면

아래를 보자

*혼자 이해한거라 틀릴 수도 있어요.

1.일반 사용자가 프로그램을 사용한다.

2.일반 사용자는 하드웨어를 직접 제어하게되면 문제가 발생할수 있기에 커널 모드로 프로그램이 실행되면서 하드웨어 제어를 커널에서만 할 수 있도록 하였다.

3.프로그램이 하드웨어 사용이 다 끝나면 다시 그 프로그램은 사용자 모드로 제어권이 넘어가게 된다.

대충 이해 됬으면 개념도를 보도록 하자

이해가 다 되었어도 개념도를 보니 다시 멍해지는 기분이다...

천천히 한번 보도록하자

자료사진과 보고 참고한 곳은 : http://www.scitech.co.kr/upload/book_image/s_402/ESDP-Ch06.PDF

이걸로 많이 참고했습니다.

포스팅은 여기까지.

http://blog.naver.com/stillstick/220463132509

예전에 한번 비슷한 글을 레퍼런스 한적이 있는데 같은건지는 모르겠으나.. 괜찮은 글이라서 ㄱ ㄱ

씹어먹는 C++ 토막글 ② - 람다(lambda) 함수

출처 : http://itguru.tistory.com/196

안녕하세요? 이 글은 지난번에 우측값 레퍼런스에 관련한 글에 이어서 두 번째로 쓰는 C++ 토막글 입니다. C++ 토막글에서는 주로 C++ 11 에 추가된 최신 기술들을 다루고 있는데요, 아직 국내에 자료가 많이 부족하다 보니 체계적으로 쓰인 외국 자료들을 번역하는 형태로 제공하고 있습니다. 이 글은 http://ciere.com/cppnow12/lambda.pdf 에 올라온 pdf 자료를 바탕으로 번역된 글입니다. 사실 이 pdf 는 내용은 없고 소스만 있는 발표 자료이지만, 제가 발표자가 되었다고 가정해서 내용을 소개해보고자 합니다. 이 글이 C++ 11 의 강력한 기술인 Lambda 를 이해하는데 많은 도움이 되기를 바라겠습니다 :) 

간단히 Functor 를 이용한 코드와 Lambda 를 이용한 코드를 비교해 보아도 그 차이를 실감할 수 있을 것입니다.

자 그럼 Lambda 를 사용하기 위해 Lambda 를 어떻게 C++ 에서 정의하는지 살펴보도록 합시다.

람다는 위 그림과 같이 4 개의 부분으로 구성되어 있습니다. 그 4 개의 부분은 각각 개시자 (introducer), 인자(parameters), 반환 타입 (return type), 그리고 함수의 몸통 (statement) 라 합니다. 일단, 람다 맨 처음에 나타나는 [] 는 개시자로, 그 안에 어떤 외부 변수를 써 넣는다면 람다 함수가 이를 Capture 해서, 이 변수를 람다 내부에서 이용할 수 있게 됩니다 (이에 대한 이야기는 뒤에서...) 위 경우 my_mod 라는 변수를 람다 내부에서 이용할 수 있게 됩니다. 

그 다음의 () 는 람다가 실행시 받을 인자들을 써 넣습니다. 위 람다는 int 형의 v_ 를 인자로 받는 군요. 여기는 그냥 실제로 함수에서 사용하는 인자 리스트와 동일하게 적어주면 됩니다. 이제, 그 옆으로 보면 -> 가 있고 반환 타입을 적어주시면 됩니다. 위 람다의 경우 int 를 리턴합니다. 마지막으로 람다 내부에서 실행할 내용을 적어주면 되는데, 위 람다의 경우 v_ 와 my_mod 를 모듈러 연산해서 그 결과를 리턴하네요. 

만일 우리가

위와 같이 코드 상에 Lambda 를 썼다고 해봅시다. 그러면 런타임시 이름은 없지만, 메모리 상에 임시적으로 존재하는 클로져 (Closure) 객체가 생성됩니다. 이 클로져 객체는 함수 객체(function object)처럼 행동합니다. (이러한 연유로 람다를 람다 함수라고 부르는 경우가 있습니다 - 사실 엄밀히 말하면 클로져 객체지 함수는 아닙니다)

그렇다면

를 실행하였을 때 어떠한 결과가 나올까요? 일단 

로 임시적인 클로져 객체가 생성되었는데 () 를 붙여서 바로 이 임시 클로져 객체를 실행시켜 버리지요. 위 람다는 Capture 하는 변수들도 없고, 인자로 받는 것도 없고 리턴 타입도 없고 (참고로 리턴 타입이 void 일 경우 -> 를 생각 가능합니다) 함수 몸통만 덜렁 있기에 특별히 생각할 것도 없이 함수 몸통만 덜렁 실행되서

라고 나오게 됩니다.

그러면 조금 더 복잡한 예제를 살펴볼까요?

는 어떨까요. 

부분에서 인자로 v 를 받는 클로져가 생성되었는데, (7) 로 이 클로져에 인자로 7 을 전달시키면서 실행시켜버립니다. 따라서 모두가 예상 하였던 결과인

가 나오겠네요.

람다 자체가 함수 처럼 자유롭게 사용할 수 있는 것이기 때문에 인자로 (당연히) 레퍼런스 들도 전달 가능합니다. 예를 들어

를 실행해보면

가 나옵니다.

참고로 받는 인자가 없을 경우, 예컨대 

의 경우 인자 () 를 생략 할 수 있습니다. 즉, 

도 동일한 의미입니다. (하지만 [] 는 지울 수 없습니다! ) 

사실 많은 경우 우리의 람다 안에서 람다 밖에 있는 변수들에게 접근하고 싶을 때가 있을 것입니다. 물론 "그렇다면 그 변수들을 그냥 인자로 받아버리면 되자나!" 라고 반문할 수 도 있겠지만, for_each 나 fill, transform 등의 C++ 의 파워풀한 STL 을 수행하기 위해서는 인자들을 맞추어 주어야 하는데 이 때문에 함수 내부로 전하고 싶어도 전달하지 못하는 인자들이 있기 마련 입니다. 

따라서 이를 방지하기 위해, 람다 내부와 소통할 수 있는 또다른 문, Capture 를 제공하고 있습니다. Capture 하고자 하는 내용은 앞에서 말했듯이 [] 안에 들어오게 되는데, 대표적으로 아래의 4 개의 형태들이 있습니다.

1. [&]() { . . . } 외부의 모든 변수들을 레퍼런스로 가져온다. (함수의 Call - by - reference 를 생각)
2. [=]() { . . . } 외부의 모든 변수들을 값으로 가져온다. (함수의 Call - by - value 를 생각)
3. [=, &x, &y] { . . . }, [&, x, y] { . . . } 외부의 모든 변수들을 값/레퍼런스로 가져오되, x 와 y 만 레퍼런스/값으로 가져온다
4. [x, &y, &z] { . . . } 지정한 변수들을 지정한 바에 따라 가져온다. 

 한 가지 흥미로운 점은 Capture 를 레퍼런스가 아닌 값으로 할 때 언제 Capture 가 되냐는 것입니다.

과연 위 소스에서 v 는 func 이 처음 정의될 때, 즉 클로져 객체가 생성될 때 Capture 될까요, 아니면 func 이 실행될 때 일까요? 만일 전자라면 42 가 출력될 것이고 후자라면 8 이 출력될 것입니다. 

과연!

흥미롭게도 람다는 클로져 객체가 처음 생성될때 변수들의 값을 Capture 합니다.

Capture 를 값으로 할 때 주의점은 그 변수들에는 자동으로 const 속성이 붙는 다는 것입니다. 즉 값으로 Capture 시 그 변수들의 내용을 바꿀 수 없습니다. 따라서 아래와 같은 코드는

컴파일 오류 " 'i': a by-value capture cannot be modified in a non-mutable lambda " 가 나게 됩니다. 위 코드에서 i 는 분명히 값으로 받았으므로 const 인데, i *= 2 를 통해 i 의 값을 바꾸려 하고 있으니 오류가 발생한 것입니다. 하지만, 함수 내부에서 i 의 값을 바꾸고자 하면 어떨까요? (물론 실제 외부의 i 의 값은 바뀌지 않습니다... 함수 내부에서만 - 마치 지역 변수처럼 말이죠) 

답은 간단합니다. 람다에 mutable 속성을 추가해주면 됩니다.

이로써 람다 내부에서 i 의 값을 변경할 수 있습니다. 물론, 다시 말하지만 외부의 i 의 값이 바뀌는 것이 아닙니다. 오직 람다 함수 내에서  '어떤 다른 i ' 의 값이 두 배가 되는 것이지요. 그 결과

로 나타남을 알 수 있습니다.

이제 그럼 조금 복잡한 코드를 살펴볼까요.

사실 위 코드는 상당히 재미있는 코드입니다. extras 함수를 호출하면 람다가 각 원소를 4 로 나눈 나머지들의 합을 구해서 더해주는데요, 한 가지 궁금한점! 과연 람다에서 어떻게 m_ 을 capture 할 수 있었을까요? 람다는 여기서 암묵적으로 (implicit) 클래스의 this 를 Capture 했기 때문에 m_ 을 접근할 수 있었던 것입니다. 

따라서 위 코드는

으로 성공적인 결과를 보여줍니다.

이렇게 this 를 암묵적으로 Capture 할 수 있기에 아래와 같은 놀라운 일도 발생할 수 있습니다.

위 코드를 언뜻 보면 i 를 값으로 capture 햇는데 어떻게 8 을 대입할 수 있냐고 물을 수 있는데, 사실 this 를 Capture 해서 this.i = 8 을 통해 mutable 없이도 값을 바꿀 수 있습니다. 왜냐하면 분명 this.i = 8 에서 상수인 this 를 변경한 것은 아니기 때문이죠.

Capture 되는 개체들은 모두 람다가 정의된 위치에서 접근 가능해야만 합니다. 예를 들어

의 코드는 람다의 위치에서 i, j 모두 접근 가능하기 때문에 Capture 가능하므로 정상적으로

가 나옵니다.

그렇다면 아래 코드는 어떨까요?

바깥의 람다에서 i 를 Capture 하였기에, 바깥의 람다 몸통 안에서 i 를 사용할 수 있겠지요. 따라서 내부의 람다는 i 를 Capture 할 수 있게 됩니다. 그렇기에, 위와 동일한 결과인

가 나오게 됩니다. 하지만, 만일 바깥의 람다에서 i 를 Capture 하지 않았다면 어떨까요.

그러면 예상했던 대로 컴파일 오류 error C3493: 'i' cannot be implicitly captured because no default capture mode has been specified 가 나오게 됩니다. 

조금 더 복잡한 예로 아래의 코드를 살펴봅시다.

일단 바깥의 람다는 i 를 값으로 Capture 하였기 때문에 바깥의 람다(f) 몸통에서는 i 에 const 속성이 붙습니다. 그런데, 내부의 람다(m) 가 그 i 를 레퍼런스로 Capture 해서 값을 변경하려고 했습니다. 그렇다면, 당연히 오류가 나겠지요. 실제로 컴파일 오류 'i': a by-value capture cannot be modified in a non-mutable lambda 가 발생하게 됩니다.

이를 해결하려면, 당연히도 mutable 속성을 붙여주면 됩니다. 

i 자체가 값으로 입력 되었기 때문에 outer i 의 값은 바뀌지 않고 8 로 남아 있고, 값으로 받은 i 가 m 에 의해서 2 로 나눠지므로 4 가 됩니다. 따라서, 그 결과 

로 나오게 되죠.

모든 클로져 객체들은 암묵적으로 정의된 복사 생성자(copy constructor)와 소멸자(destructor)를 가지고 있습니다. 이 때 클로져 객체가 복사 생성 될 때 값으로 Capture 된 것들의 복사 생성이 일어나겠지요. 아래의 예를 한번 보도록 하겠습니다.

일단 

와 같이 생성, 복사 생성, 소멸, 그리고 대입 연산을 확인할 수 있는 trace 라는 구조체를 정의해놓고 

를 한다면 어떻게 나올까요? f 에서 t 를 사용하지 않았으므로, t 를 Capture 하지 않게 됩니다. 따라서 그냥

이 나오게 됩니다.

그렇다면 아래의 예는 어떨까요

먼저 m1 을 생성하면서, 람다가 t 를 Capture 하였으므로 t 의 복사 생성자가 호출되게 됩니다. 왜냐하면 값으로 받았기 때문이지요. 만일 레퍼런스로 받았다면 복사 생성자가 호출되지 않았을 것입니다 (확인해보세요!) 그리고 아래의 auto m2 = m1; 에서 클로져 객체의 복사 생성이 일어나는데, 이 때, 클로져 객체의 복사 생성자가 값으로 Capture 된 객체들을 똑같이 복사 생성 해주게 됩니다. 따라서 또 한번 t 의 복사 생성자가 호출되겠지요. 그 결과 아래와 같이 출력됩니다.

std::function 은 위와 같이 std::function < 반환 타입 ( 인자 ) > 와 같은 형태로 쓰며, Capture 가 있어도 상관이 없습니다. 물론 위 코드는 실행하면 

와 같이 잘 나오지요.

이 std::function 을 통해 아래와 같이 재밌는 코드도 짤 수 있습니다.

이것이 가능한 이유는 만일 auto 를 이용하였더라면 auto f1 을 한 시점에서 f1 이 명확히 구현이 되어야 컴파일러에서 타입을 추정할 수 있는데, 위와 같은 경우 f1 을 구현하려면 f2 를 먼저 구현해야 하고, 또 f2 를 구현하려면 다시 f1 을 먼저 구현해야 하는 순환적인 논리 딜레마에 빠지게 됩니다. 따라서 function 을 이용해서 f1 을 선언만 해 놓은 뒤, f2 를 구현하고, 다시 f1 을 구현하면 됩니다. 

위 코드를 실행하면

와 같이 잘 나옴을 알 수 있습니다.

마찬가지로 아래와 같은 재귀 호출 함수도 구현할 수 있습니다.

이 역시 auto 를 이용했더라면, 처음 Capture 부분에서 Capture 하는 대상의 타입이 명확히 정해지지 않은 상태이므로 컴파일러가 타입을 추정할 수 없게 됩니다. 하지만 function 을 이용해서 성공적으로 구현할 수 있습니다. 위 계산 결과는 당연히

가 나오겠지요.

C++ 에 새롭게 추가된 람다는 기존의 C++ 과 전혀 다른 새로운 개념 입니다. 하지만 람다를 이용하면 수십줄의 코드도 한 두 줄로 간추릴 수 있는, 엄청난 기능이 아닐 수 없습니다. 

이제 여러분들 손에는 람다라는 막강한 도구가 주어졌습니다. 이를 어떻게 사용하느냐는 여러분의 몫이지요 :) 

그리고 이런 훌륭한 강의를 제공해주신 Michael Caisse 님에게 감사의 말을 전합니다. 

1
2
3
4
5
6

int main()
{
    const char *filename = "C:\\myfile.txt";

    printf("Filename is: %s\n", filename);
}

 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

1)

int a;

for(int i = 0; i < 9; i++)
{
printf("%d * %d = %d", a, (i + 1), a * (i + 1));
}

//의 방식으로 짤 수도 있겠지만

2)
if (a == 1)
{
printf("1 * 1 = 1");
printf("1 * 2 = 2");
...
printf("1 * 8 = 8");
printf("1 * 9 = 9");
}
if (a == 2)
{
...
}
if (a == 3)
...
...
...
if (a == 9)
{
printf("9 * 1 = 9");
printf("9 * 2 = 18");
...
printf("9 * 8 = 72");
printf("9 * 9 = 81");
}

//위와 같은 방식으로 짤수도 있는데 2)번과 같은 방식의 코딩이 하드코딩이다.

http://codinglove.tistory.com/79

[기본 용어 설명]

- 바이트 패딩: 

몇몇 컴파일러는 구조체의 필드를 메모리에 위치시킬때 중간에 빈공간없이 쭉 이어서 할당하는 경우도 있지만 대부분의 컴파일러는 성능향상을 위해 CPU가 접근하기 쉬운 위치에 필드를 배치하는데(OS나 컴파일러에 따라 4바이트단위 또는 8바이트 단위로 끊는작업을 함) 이를 "바이트 패딩"이라고 하며, 그러다보니 중간이 빈 공간이 들어가게 되는데 이 빈 공간을 "패딩비트"라 한다.  

* 바이트패딩을 사용했을때 왜 성능향상에 도움을 줄까? 그 해답은 아래 링크를 통해 확인바람

http://pangate.com/19

이러한 바이트 패딩 때문에 구조체 정의를 어떻게 하느냐에 따라 구조체의 크기가 달라진다. 아래 예제를 살펴보자.

예)

- 위에서 보는것 처럼 구조체 ST_TEST1, ST_TEST2의 멤버변수는 동일하다. 하지만 변수의 선언 순서에 따라 바이트패딩이 적용되서 사이즈가 다르게 된다. 

바이트 패딩 의해

ST_TEST1 은

[char c1 (1) | empty(1) | short s1(2)]   ||   [int i1(4)]                    = 총 8바이트

ST_TEST2 는

[char c1(1) | empty(3)]   ||   [int i1(4)]   ||   [short s1(2) | empty(2)] = 총 12바이트

* empty : 빈공간, 즉 패딩비트 [] : 4바이트씩 모아놓은것.

* 실제 ST_TEST1 정렬방법(char 뒤에 1바이트 패딩비트가 생기는지)을 확인하고 싶으면 디버깅 - 창 - 조사식에 각 구조체의 변수의 주소를 확인해보면 된다. 아래 스샷을 보면 c1과 s1 사이에 1바이트 빈공간이 존재한다.  

이러한 문제를 해결할수 있는 방법이 바로 #paragma pack 이다.  

사용 방법은 2가지다.

1. #pragma pack(1)  - #pragma pack(4)

1바이트 정렬 방식이 필요할때 필요한 구문에서

#pragma pack(1) 을 써주고 (2바이트 정렬이 필요하다면 #paragma pack(2))

사용이 끝난 시점에서 다시 #pragma pack(4) 를 통해 바이트 정렬 방식을 4바이트로 되돌려 놓는다.

※  

Q: 왜 굳이 1바이트 정렬 후 다시 4바이트 정렬로 되돌려야하는가??

A:  PC의 CPU에 따라 레지스터를 읽는 바이트 사이즈가 다른데 32비트 운영체제의 경우 4바이트씩 읽는다 . 이는 성능과 연관있다. (자세한 내용은 컴퓨터 구조 공부를... ) 따라서 필요시에만 정렬방법을 바꿨다가 다시 기존 바이트 정렬 방식으로 돌려 놓아야한다.

2. #pragma pack(push, 1)  - #paragma pack(pop)

- #pragma pack(push, 1) 을 통해 구조체 정렬방식을 가지고 있는 스택에 1바이트 정렬방식을 push 를 통해 입력하고 ( 이 선언 이후부터는 정렬방식이 1바이트 바뀜)  사용 후에 이전 정렬방식( 이전 방식이 꼭 4 라는 법은 없음)되돌릴때 pop을 통해 이전에 push를 통해 입력했던 정렬방법(1)을 없앤다. 이를 위해 #pragma pack(pop) 을 사용한다.

* push 와 pop 이 뭔지 생소하다면 스택(Stack)에 대해 공부할것.

사용 예)

- 스샷 화면 속 빨간 네모 속 ST_TEST2 사이즈를 보면 7로 변해있는것을 확인할수 있다.

#paragma pack 을 쓰기 전에는 12바이트.

★ 그렇다면 가장 중요한 포인트! 이 #pragma pack 어디다 쓰면 유용한 건데???

​

- 네트워크를 통한 구조체 전송시 바이트 패딩은 중요하다!

예) 만약 A시스템(32비트) B시스템(64비트)라고 가정, A시스템에서 B시스템으로 아래와 같은 구조체 패킷을 보낸다고 하면

struct ST_TEST

{

char c1;

int i1;

};

B 시스템은 바이트 패딩에 의해 A시스템과는 달리 8바이트단위로 끊는다. 따라서 첫번째 c1값만 정상이고 나머지 값들은 이상한값이 되버린다.

따라서 A시스템, B시스템 모두 바이트 패딩을 없애야 이러한 문제를 없앨수 있는데 이 해결방법이 위에 설명했던 #paragma pack 이다.  

http://blog.naver.com/dkdldhekznal/220206729625

WinCE라는 넘은 간혹 참 당확 스럽게 하는 경우가 있다.

일반 적으로 Release Mode에서는 해당(내가 작업할려는 Driver혹은 Sources가 있는 어떤 거라도) Optimize 가 Enable이 된다.

그런데 간혹 Driver작업이나 좀더 Critical한 Kernel작업을 하다가 보면 문제를 발생 시키기도 한다.

예를 들어 특정 Chips에서 아래와 같은 작업이 반드시 필요하다고 한다면

A = 0;

A = 1;

A = 0;

WinCE Compiler는 워낙 탁월한(?) 넘이라 "어라 결국 A=0 이내" 하고 위의 두 Code를 날려 버리는 경우가 발생한다.

일반 Code라면 뭐 그렇지만 Chip Register라던가 Peri.의 Reset신호라던가 할경우 위의 3 Code가 모두 필요한 상황인데,

간혼 최종 Code만 남는 경우가 발생하게 된다.

이럴 경우 해당 드라이버의 Optimize 를 Disable 할수도 없고 (물론 CONLY_FLAGS=$(CONLY_FLAGS) /Od 으로 할수도 있지만.

Optimize함으로 써 얻는 이익은 모드 포기 해야한다는, 쩝...)

그럴 경우 해당 루틴이있는 Function에 대해서만 Opimize Disable을 할수있는 방법을 WinCE는 제공한다.(방법 을 제공한다는 것은

결국 저런일이 빈번하게 일어날수 있다는 것을 시인하는 것일까? )

방법 : 아래와 같이 하면 끝

#pragma optimize( "g", off )

void example_function(void)

{

 .....

A = 0;

A = 1;

A = 0;

}

#pragma optimize( "g", on)

PS : 해당 Code가 정상적으로 생성되어 컴파일 되어 있는지는 해당 파일을 Assembly 파일로 만들어서 해당 Code를 확인하면 된다.

ms-help://MS.WindowsCE.500/wcepbguide5/html/wce50confilealternatives.htm

sources에 추가 : CONLY_FLAGS=$(CONLY_FLAGS) /FA

http://seungwan76.blog.me/140109794967

람다 함수 활용(1)

지금까지 First-Class Object, Higher-Order Function, Closure와 같은 조금은 지루한 개념들을 살펴봤습니다. 이런 개념들을 설명하지 않으면 람다 함수를 함수 포인터나 함수 객체를 대체하는 Syntactic Sugar로 오해할 수도 있기 때문입니다. 또 어떻게 람다 함수를 일반 변수처럼 사용할 수 있는지 배경 지식을 설명하기 위해서였습니다. 

그럼 이 람다 함수를 어디에 사용하면 좋을까요?앞으로 4가지 활용 예를 살펴 보겠습니다.


① 지연 호출(Deferred Call)에 활용
vector와 같은 자료구조에 저장한 후에 필요한 특정 시점에 호출하는 것입니다.
아래 예제에서는 람다 함수를 이용해 Task를 만들고 TaskManager라는 컨테이너 클래스를 통해 특정 시점에 람다 함수가 실행되는 것을 나타내고 있습니다.

② 비동기 호출과 결과 코드의 응집성을 높이는 데 활용
비동기 처리 코드의 문제점은 비동기 요청 함수를 호출하는 곳과 결과를 처리하는 함수가 동떨어져 있어 로직 흐름을 파악하기 어렵다는 것입니다. 비동기 요청 함수를 호출할 때 결과 처리에 대한 코드를 람다 함수로 구현해 파라미터로 전달하면 코드 응집성이 높아질 수 있습니다.
아래 예제에서는 Client 클래스의 요청에 대한 처리가 비동기적으로 이뤄질 때 람다 함수를 이용해 요청 시점에 결과를 어떻게 처리할 것인지 기술하는 것을 나타내고 있습니다.

③ 일회성 함수를 쉽게 구현하기 위해 활용
특히 STL을 이용하는 데 유용합니다. STL 알고리즘 함수들의 입력 파라미터로 람다 함수를 넘겨주면 따로 함수 객체를 정의하는 번거로움이 사라지고 코드 응집성이 높아지므로 STL 함수의 작동을 더 쉽게 이해할 수 있습니다. 아래 예제에서는 함수 객체와 람다 함수 이용을 비교해서 보여주고 있습니다.

포스팅이 길어졌네요~ 
다음 글에서 람다 활용에 대해 마저 이야기 하고 "람다 이야기" 시리즈를 마치도록 하겠습니다.

http://tedahn.tistory.com/24

7. VSTS 2010 Team Blog -  http://vsts2010.net/category/Language%20Development/C++0x

http://tedahn.tistory.com/25

가상함수를 생성자와 소멸자에 넣으면 호출이 안된다고 되어있어서

실험삼아 책에 나와있는 코드를 테스트 해 보았는데 호출이 되었습니다. -_-;;

그리고 생성자와 소멸자에 가상함수를 쓰면 안된다고 나와있고 거기에 대한 자세한

설명이 없더군요. 이런저런 고민을 해 보았는데 왜 쓰면 안되는지 모르겠습니다.

코드는 대충..

class A
{
public:
A(){
test();
}
~A(){
test();
}
virtual test()
{
printf("test\n");
}
};

void main()
{
A a;
}

출력
test
test

간단하게 이정도네요.
왜 호출이 되고 왜 쓰면 안되는지 설명 부탁드립니다.

----------------------------------------------------------------

이펙티브 C++ 참고하세요.
항목 9: 객체 생성 및 소멸 과정 중에는 절대로 가상 함수를 호출하지 말자

대충 요약하면 자식이 생기기도 전에 자식 함수 호출하면 안되는 거고
자식이 사라진 다음에 자식 함수 호출 하면 안되서 그렇습니다.

https://kldp.org/node/98424

#include <iostream>

class A{

public :

void add(int a){

}

void add(int a, int b){

void (A::*fn)(int) = &A::add;

void (A::*fn1)(int,int,int) = &A::add;

printf("%x\t%x", fn,fn1);

}

void add(int a, int b, int c){

}

};

int _tmain(int argc, _TCHAR* argv[])

{

A ai;

A ai1;

A ai2;

ai.add(1,3);

std::cout << std::endl;

ai1.add(1, 3);

std::cout << std::endl;

ai2.add(1, 3);

return 0;

}

동일한 함수의 주소가 나옴을 알 수 있다

http://gcstudy.tistory.com/60

deprecated declaration (VC++)

http://mwultong.blogspot.com/2006/12/c-hex-16-10-hex-string-to-int-number.html

십육진수 헥사 문자열을, 숫자(정수)로 변환 예제

소스 파일명: 0.cpp

http://cafe.naver.com/dxgameprogramming/1443

http://cafe.naver.com/mathclub/84160

수학에서 봤을 때.. 무한 소수란 것이 있습니다.

예를 들어서

1/3 = 0.333333......

즉 3이 연속해서 나타나죠.

이 3은 끝없이 나타나기 때문에 무한소수라고 합니다.

컴퓨터에서는 아쉽게도 유리수형태의 수를 표현하는 자료형이 없습니다.

컴퓨터에서는 부동소수점(Floating point number)이란 자료형이 있죠.

부동소수점이라는 것은 소수점 위치를 옮겨서 잡는다는 뜻을 가지고 있습니다.

1.M 이란 소수가 있다면, 이 소수점 위치를 왼쪽 또는 오른쪽으로 지수부(E)로 옮기게 됩니다.

소수형태의 표현이므로 컴퓨터에서 표현할 수 없는 유리수들이 많겠죠.

컴퓨터는 이진수 체계를 가지고 있습니다.

그러다보니 컴퓨터에서 표현할 수 없는 유리수는 우리가 수학에서 사용하는 것보다 더 많습니다.

0.2  를 표현하고자 합니다.  이 수는 유한소수입니다만, 컴퓨터에서는 무한소수가 됩니다.

십진법 체계에서는 분모가 2 또는 5라는 소인수만 가져야죠?  왜냐하면 2x5 = 10 이기 때문이죠.

이진법 체계에서는 분모가 2라는 소인수만 가져야 합니다.  2는 소수이기 때문이죠.

0.2 를 이진법으로 표현할려면.. 무한소수가 됩니다.  왜냐하면 1/5 = 0.2 이기 때문에 분모에 5라는 소인수가 존재하죠.

0.2 를 이진법으로 표현할 때에는 정수부를 무조건 1로 만들어야 합니다.

0.2 * 8 = 1.6 이죠.  그럼 여기서 출발을 합니다.

1.6을 이진법으로 표현하면..

1.100110011001....

과 같이 소수부가 1001 이 반복하게 됩니다.  (너무나도 당연하겠지만 분모가 5이므로 4의 약수로 순환고리를 갖습니다.)

그런데 무한한 메모리를 가진 것이 아니기 때문에.. 소수부를 무한히 표현할 수 없습니다.

그래서 우리는 여기서 오차가 발생합니다.  이것을 Round off error 라고 하며, 우리말로 반올림 오차라고 합니다.

이 값은 하나의 숫자 상태에서는 중요하지 않습니다.  유효자리수 대비 2^-23 이라는 아주 작은 숫자(백만분의 1 오차)이기 때문이죠.

하지만 이 값에 숫자들을 곱하거나 더하거나 한다면 반올림 오차는 증가하게 됩니다.

프로그램을 할 때에는 이 반올림 오차에 대해서 충분하게 고려를 해주어야 합니다.

보통 부동소수점 연산에서는 == 을 사용하지 않습니다.  반올림 오차 때문이죠.

x == 0.0 대신에 우리는 x < 0.00001 && x > -0.00001 과 같이 합리적인 형태로 검사를 합니다.

http://www.devpia.com/MAEUL/Contents/Detail.aspx?BoardID=51&MAEULNO=20&no=8308

01: #include <iostream>
02: #include <algorithm>
03: using namespace std;
04: 
05: struct ShowFunctor
06: {
07:         void operator()(int n) const
08:         {
09:                 cout << n << endl;
10:         }
11: };
12: int main()
13: {
14:         int x[10] = { 1,2,3,4,5,6,7,8,9,10};
15:         for_each( x, x+10, ShowFunctor() );
16: }

1: int main()
2: {
3:         int x[10] = { 1,2,3,4,5,6,7,8,9,10};
4:         for_each( x, x+10, [](int n){ cout << n << endl;} );
5: }

01: class closure_object
02: {
03: public:
04:         void operator()(int n) const
05:         {
06:                 cout << n << endl;
07:         }
08: };
09: int main()
10: {
11:         int x[10] = { 1,2,3,4,5,6,7,8,9,10};
12:         for_each( x, x+10, closure_object() );
13: }

01: #include <iostream>
02: #include <algorithm>
03: using namespace std;
04: 
05: int main()
06: {
07:         int x[10] = { 1,2,3,4,5,6,7,8,9,10};
08: 
09:         for_each( x, x + 10, [](int n ) {
10:                 if ( n % 2 == 0 )
11:                         cout << "even ";
12:                 else
13:                         cout << "odd ";
14:         });
15: 
16:         cout << endl;
17: }

01: #include <iostream>
02: #include <algorithm>
03: #include <vector>
04: using namespace std;
05: 
06: int main()
07: {
08:         int x[10] = { 1,2,3,4,5,6,7,8,9,10};
09:         vector<double> v;
10: 
11:         transform( x, x+10, back_inserter(v), [](int n) -> double {
12:                 if ( n % 2 == 0 ) return n;
13:                 return n / 2.0;
14:         });
15: 
16:         for_each( v.begin(), v.end(), [](double n) { cout << n << " ";});
17:         cout << endl;
18: }

01: #include <iostream>
02: #include <algorithm>
03: #include <vector>
04: using namespace std;
05: 
06: int main()
07: {
08:         int x[10] = { 1,2,3,4,5,6,7,8,9,10};
09:         vector<double> v1(10);
10:         vector<double> v2(10);
11: 
12:         // return 문장이 한 개 입니다. "?>double" 는 생략 가능 합니다.
13:         transform( x, x+10, v1.begin(), [](int n) { return n / 2.0;});
14: 
15:         // return 문이 없습 니다. “?>void” 는 생략 가능 합니다.
16:         for_each( v1.begin(), v1.end(), [](double d) { cout << d << " ";});
17:         cout << endl;
18: 
19:         // 2개 이상의 return 문이 있습니다. 반드시 "?>double" 을 표시 해야 합니다.
20:         transform( x, x+10, v1.begin(), [](int n)->double {
21:                 if ( n % 2 == 0 ) return n;
22:                 return n / 2.0;
23:         });
24: 
25:         for_each( v1.begin(), v1.end(), [](double d) { cout << d << " ";});
26:         cout << endl;
27: 
28:         // 역시 1개의 return 문 입니다.
29:         transform( x, x+10, v1.begin(), v2.begin(), [](int a, double d){ return a + d;});
30:         for_each( v2.begin(), v2.end(), [](double d) { cout << d << " ";});
31:         cout << endl;
32: }

01: int main()
02: {
03:         int x[10] = { 1,3,5,7,9,11,13,15,17,19};
04: 
05:         int low = 12;
06:         int high = 14;
07: 
08:         int* p = find_if( x, x+10, [low, high](int n) { return low < n && n < high;});
09: 
10:         cout << *p << endl;
11: }

01: class closure_object
02: {
03: private:
04:         int min;
05:         int max;
06: public:
07:         closure_object( int l, int h ) : min(l), max(h) {}
08:         bool operator()(int n) const { return min < n && n < max; }
09: };
10: 
11: int main()
12: {
13:         int x[10] = { 1,3,5,7,9,11,13,15,17,19};
14:         int low = 12;
15:         int high = 14;
16: 
17:         int* p = find_if( x, x+10, closure_object(low, high) );
18:         cout << *p << endl;
19: }

1: int main()
2: {
3:         int x[10] = { 1,3,5,7,9,11,13,15,17,19};
4:         int low = 12;
5:         int high = 14;
6: 
7:         int* p = find_if( x, x+10, [=](int n) { return low < n && n < high;});
8:         cout << *p << endl;
9: }

1: int main()
2: {
3:         int x[10] = { 1,2,3,4,5,6,7,8,9,10};
4:         int sum = 0;
5: 
6:         // x~x+10 에서짝수의합을구하는람다표현식입니다.
7:         for_each( x, x+10, [&sum] (int n) { if ( n % 2 == 0 ) sum += n;});
8: 
9:         cout << sum << endl;
10: }

01: class closure_object
02: {
03: private:
04:         int& ref;
05: public:
06:         closure_object ( int& r ) : ref(r) {}
07:         void operator()(int n) const { if ( n % 2 == 0 ) ref += n; }
08: };
09: 
10: int main()
11: {
12:         int x[10] = { 1,2,3,4,5,6,7,8,9,10};
13:         int sum = 0;
14: 
15:         for_each( x, x+10, closure_object( sum ) );
16:         cout << sum << endl;
17: }

01: int main()
02: {
03:         int x[10] = { 1,2,3,4,5,6,7,8,9,10};
04:         int low = 3;
05:         int high = 8;
06:         int sum = 0;
07: 
08:         // low ~ high 사이의 합을 구하는 람다 표현식 입니다.
09:         for_each( x, x+10, [=, &sum](int n) { if ( low < n && n <high) sum += n; });
10:         cout << sum << endl;
11: }

01: class Test
02: {
03: public:
04:         void foo() const
05:         {
06:                 int x[10] = { 1,2,3,4,5,6,7,8,9,10};
07: 
08:                 // 멤버 data인 base를 캡쳐 하려고 한다. 하지만 error.
09:                 for_each( x, x+10, [base](int n) { cout << base + n << " ";});
10:                 cout << endl;
11:         }
12: 
13:         Test() : base(100) {}
14: private:
15:         int base;
16: };
17: 
18: int main()
19: {
20:         Test t;
21:         t.foo();
22: }

01: class Test
02: {
03: public:
04:         void foo() const
05:         {
06:                 int x[10] = { 1,2,3,4,5,6,7,8,9,10};
07: 
08:                 for_each( x, x+10, [this](int n) { cout << base + n << " ";}); // 또는 [=]
09:                 cout << endl;
10:         }
11:         Test() : base(100) {}
12: private:
13:         int base;
14: };

01: int main()
02: {
03:         int x[10] = {0};
04:         int y[10] = {0};
05:         int i = 0;
06:         int j = 0;
07: 
08:         generate( x, x+10,[&i]() { return ++i;});
09:         generate( y, y+10,[&j] { return ++j;}); // () 를생략해도된다.
10: 
11:         for_each( x, x+10, [](int n) { cout << n << " ";});
12:         cout << endl;
13: 
14:         for_each( y, y+10, [](int n) { cout << n << " ";});
15:         cout << endl;
16: }

01: int main()
02: {
03:         int x[10] = { 1,3,5,7,9,2,4,6,8,10};
04:         int i = 0;
05: 
06:         // error. 값으로캡쳐한지역변수의값을변경할수없다.
07:         for_each( x, x+10, [=](int n) { cout << ++i << " : " << n << endl;});
08: 
09:         // ok.
10:         for_each( x, x+10, [=](int n) mutable { cout << ++i << " : " << n << endl;});
11: }