In search of wonder

굿바이 티스토리

In search of dream 꿈찾아고고씽 — Thu, 29 Dec 2011 22:43:16 +1100

새로운 블로그로 이사갑니다.

Parody Terrorist Interview - Are Those Subtitles??

In search of dream 꿈찾아고고씽 — Mon, 26 Dec 2011 11:21:24 +1100

ㅋㅋㅋㅋㅋㅋ

매쉬업 장난감 - NSW Crime news

In search of dream 꿈찾아고고씽 — Sat, 24 Dec 2011 19:06:51 +1100

토픽

New South Wales의 범죄현황 리포트를 Google Maps 에 매쉬업해주는 장난감을 한번 만들어 봤습니다.

개발툴

- Eclipse

- Python 2.6

- Google Maps API ver 3

- Javascript

스크린 샷

접속 URL

http://nswcrime.alwaysdata.net/crimewatch/crimenews.html

무료 웹 호스팅하는 곳인데, ~~계약 위반으로 언제 짤릴지 모른다는~~...ㅠㅠ 얼렁 괜찮은 유료 서비스 하나 가입하겠네요. 지도 데이터는 1시간마다 업데이트 됩니다.

후기

자바스크립트가 생각보다 강력한 언어라는 생각이 들었습니다. 십 몇년 전에 갖고 놀던 그 언어가 아닌 듯 합니다. @.@ 구글 맵스 팀이 왜 자바스크립트를 선택했는지 이제 좀 이해가 갈락 말락.

파이썬은 역시 이런 초간단/초스피드 어플리케이션 개발에 쵝오.

Further works

코드 정리좀 해서 웹에도 올리고, 기회가 되면 안드로이드 플랫폼으로 포팅도 한번 해봐야 겠습니다.

C++11 스터디 노트 (14/n) - move semantics (3)

In search of dream 꿈찾아고고씽 — Thu, 22 Dec 2011 12:22:36 +1100

이번 포스트에서는 Perfect forwarding 에 대해 알아봅시다.

우리말로는 완전 포워딩? 완벽 포워딩 이정도 되겠습니다만, 한글로 번역하니 역시 어색한 감이 있네요.

C++ Forwarding Problem

일단 아래 코드를 보시죠.

1 #include <iostream>

3 void Foo(int& i)

4 {

5 std::cout<<"Passed value: "<<i<<std::endl;

6 }

8 void ForwardThis(int& i)

9 {

10 Foo(i);

11 }

13 int main()

14 {

15 int a = 1;

16 ForwardThis(a);

17 return 0;

18 }

실행 결과는 아래와 같습니다.

Passed value: 1

계속하려면 아무 키나 누르십시오 . . .

아무런 문제없이 실행됩니다.

main 함수 내부 코드를 보면 라인 16에서 ForwardThis 라는 함수를 호출하고 a 라는 변수를 넘겨주고 있습니다. a 라는 변수는 1이라는 상수값(r-value)을 가지고 있는 L-Value 입니다. 따라서 ForwardThis 라는 함수가 받아야 할 파라미터 형식인 레퍼런스 타입의 정수형으로 변환될 수 있습니다.

C++ 11 표준 어법으로 좀 더 정확히 말해봅시다.

ForwardThis 함수가 받아야할 파라미터 형식은 L-Value 레퍼런스 타입입니다. a는 lvalue 이므로 당연히 ForwardThis 함수에 파라미터로 넘겨줄 수 있습니다.

이제 main 함수 내부에 한줄 추가해봅시다. (라인 17 입니다)

13 int main()

14 {

15 int a = 1;

16 ForwardThis(a);

17 ForwardThis(1);

18 return 0;

19 }

의미상으로 볼 땐 같습니다. 16f라인에서는 a 라는 변수(L-Value) 를 통해 1을 넘겨주고 있지만, 17라인에서는 바로 1 (R-Value) 을 넘겨주고 있습니다.

위 코드는 컴파일러에서 다음과 같은 에러를 냅니다.

error C2664: 'ForwardThis' : cannot convert parameter 1 from 'int' to 'int &

int 를 int& 로 바꿀 수 없다는 불평을 하고 있습니다.

R-Value Reference 관련 포스트에서 언급한 대로 L-Value 레퍼런스는 그 우측값으로 L-Value 만 받을 수 있습니다. 1은 L-Value 가 아닌 R-Value 입니다. 그렇기 때문에 컴파일러는 에러를 내는 겁니다.

함수 오버로딩을 이용한 Forwarding 문제 해결

이 문제를 해결하기 위해서는, ForwardThis 함수와 Foo 함수의 시그내쳐를 변경해서 overload 된 함수를 제공해주면 됩니다. 아래처럼요.

1 #include <iostream>

2 void Foo(int& i)

3 {

4 std::cout<<"Passed value: "<<i<<std::endl;

5 }

6 void Foo(const int& i)

7 {

8 std::cout<<"Passed value: "<<i<<std::endl;

9 }

10 void ForwardThis(int& i)

11 {

12 Foo(i);

13 }

14 void ForwardThis(const int& i)

15 {

16 Foo(i);

17 }

19 int main()

20 {

21 int a = 1;//ok

22 ForwardThis(a);//ok

23 ForwardThis(1); //ok

24 return 0;

25 }

실행결과입니다.

Passed value: 1

계속하려면 아무 키나 누르십시오 . . .

이제는 에러가 없네요. 근데, 왜 에러가 없죠? ^^

ForwardThis(a); 를 호출한 라인 22는 라인 10과 2의 함수들을 호출하지만, ForwardThis(1); 은 라인 14 와 6의 함수를 호출하기 때문입니다.

정수형 타입의 a 변수에 1을 저장해서 넘겨주는 것과 1을 바로 넘겨주는 것.

어차피 같은 거 아닐까요? 의미상으론 같지만, 컴파일러 내부적으로는 엄격하게 L-Value 와 R-Value, 정확히 말하면, 해당 expression의 constness 를 체크하고 있었던 것입니다.

그냥 이렇게 쓰면 되는거 아닌가요? 그때 그때 필요한 파라미터 타입을 오버로딩해서 쓰면 되잖아요?

맞습니다. 그래도 됩니다.

하지만, 함수 파라미터가 하나가 아니라면 어떨까요? 두 개라면? 세 개라면?

게다가 함수 호출하는 부분에서 ForwardThis(1,a,3,...) 이런 식으로 호출한다면요?

가능한 조합을 남김없이 찾아내서 하나 하나, 꼼꼼하게, 디테일하게, 오버로딩 해줘야 됩니다.

생각만해도 끔찍하지 않습니까?

"난 단지 파라미터를 포워딩해주고 싶었을 뿐이라고요" 라고 컴파일러에게 항변하고 싶지만, C++의 현재 구현으로는 간단히 해결할 수 없는, 이런 문제가 있었던 겁니다.

R-Value Reference를 이용한 Perfect Forwarding

이제 C++11에서 새롭게 도입된 rvalue reference 를 이용해 문제를 좀더 간단히 해결할 수 있게 되었습니다.

바로 ForwardThis 함수의 파라미터 타입을 L-Value 레퍼런스인 int& 에서 R-Value 레퍼런스인 int&& 로 바꿔주기만 하면 됩니다.

46 void ForwardThis(int&& i)

47 {

48 Foo(i);

49 }

어떻게 이게 가능할까요.

C++11이 나오기 전에는, 레퍼런스 변수에 대해 다시 레퍼런스 변수로 지정하는 것은 에러였습니다.

그러나, C++11 에서는 다음과 같은 Reference Collapsing Rule 을 도입했습니다.

T&의 & ==> T& (L-Value 레퍼런스의 L-Value 레퍼런스는 L-Value 레퍼런스)
T&의 && ==> T& (L-Value 레퍼런스의 R-Value 레퍼런스는 L-Value 레퍼런스)
T&&의 & ==> T& (R-Value 레퍼런스의 L-Value 레퍼런스는 L-Value 레퍼런스)
T&&의 && ==> T&& (R-Value 레퍼런스의 R-Value 레퍼런스는 R-Value 레퍼런스)

따라서,

1. ForwardThis(int&& i) 함수가 L-Value 타입의 인자 i에 대해 호출되면, 위의 룰 # 2에 의해 i는 L-Value 로 추론됩니다.

2. ForwardThis(int&& i) 함수가 R-Value 타입의 인자 i에 대해 호출되면, i는 자연스럽게 R-Value 로 추론됩니다.

좀 복잡하긴 한데, 일단 이렇게 이해하고 넘어가야겠습니다. 저도 @.@

그런데, 여기서 VS2010 베타버전을 사용하시는 분들이 잠깐 알아두셔야 할 게 있습니다.

C++11 으로 확정되기 전, C++0x 표준에서는 위의 main 함수내 코드를 하나도 바꾸지 않아도 됬었습니다.

따라서, C++0x 표준을 준수한 Visual Studio 2010 Beta 버전에서는 아래코드가 아무 이상없이 동작했습니다.

1 #include <iostream>

2 void Foo(int& i)

3 {

4 std::cout<<"Passed value: "<<i<<std::endl;

5 }

6 void Foo(const int& i)

7 {

8 std::cout<<"Passed value: "<<i<<std::endl;

9 }

10 //void ForwardThis(int& i)

11 //{

12 // Foo(i);

13 //}

14 //void ForwardThis(const int& i)

15 //{

16 // Foo(i);

17 //}

19 void ForwardThis(int&& i)

20 {

21 Foo(i);

22 }

24 int main()

25 {

26 int a = 1;//ok

27 ForwardThis(a);//error C2664

28 ForwardThis(1); //ok

29 return 0;

30 }

하지만, C++11 로 확정되면서 R-Value 레퍼런스와 관련된 작은 변화가 있었고, C++11 표준을 따른 VS2010 정식 버전에서는, 위의 27 라인에서 아래과 같은 컴파일 에러가 납니다.

error C2664: 'ForwardThis' : cannot convert parameter 1 from 'int' to 'int &&'

이 컴파일 에러를 해결하기 위해서는 std::move 함수를 사용해야 합니다.

ForwardThis(a);

라인을

ForwardThis(std::move(a));

로 바꿔주면 컴파일 에러는 해결됩니다.

std::move

위에서 언급된 std::move 함수에 대해 짤막하게 짚고 넘어갑시다.

std::move는 C++11 에서 새롭게 도입된 함수입니다. move semantics를 지원하기 위해 등장했고, 파라미터로 받는 객체의 내용을 전달해줄 함수로 복사가 아닌 이동!시켜주기 위한 함수입니다.

이를 위해 std::move는 인자로 받은 변수를 rvalue로 바꿔줍니다. 함수 내부를 보면 단지 R-Value 로 static type cast 하도록 구현 되어있습니다.

이 함수는 utility 헤더에 정의되있습니다.

C++11 스터디 노트 (13/n) - move semantics (2)

In search of dream 꿈찾아고고씽 — Wed, 21 Dec 2011 17:56:47 +1100

이번에는 C++11 의 move 생성자와 move 할당연산자에 대해 알아봅시다.

C++11 에서는 move 생성자와 move 할당 연산자를 제공합니다.

move 생성자와 move 할당 연산자의 원리는 Copy 생성자와 copy 할당연산자의 원리와 유사합니다.

자신과 동일한 타입의 객체를 인자로 받아서 새롭게 생성한 인스턴스에 그 내용을 이전합니다.

다만 차이점은 Copy 의 경우 멤버변수를 위한 메모리를 할당했어야 했는데, move 에서는 그걸 하지 않아도 된다는 것입니다.

Copy constructor

먼저 C++11 이 나오기 전에 하던대로 해봅시다.

간단히 배열을 제공하는 클래스의 예입니다. 복사생성자만 제공해줬습니다.

1 class MyArray

2 {

3 public:

4 MyArray(int size) : m_pArr(new int[size]), m_size(size) {}

6 MyArray(const MyArray& other) : m_pArr(new int[other.m_size]), m_size(other.m_size)

7 {

8 for(int i = 0; i < m_size; i++)

9 {

10 m_pArr[i] = other.m_pArr[i];

11 }

12 }

14 ~MyArray()

15 {

16 delete [] m_pArr;

17 }

20 private:

21 int* m_pArr;

22 int m_size;

24 };

역시 복사 생성자 내부에서 새롭게 메모리를 할당한 후, 멤버 간의 복사가 이루어지고 있습니다.

별 무리 없는 클래스입니다.

Move constructor

위의 클래스를 C++11 에서 지원하는 move 생성자(내부적으로 r-Value 레퍼런스를 이용한) 를 이용하여 내부적으로 복사없이, 인스턴스의 리소스 소유권 이전을 간단하게 해결할 수 있습니다. move 생성자를 추가한 아래 코드를 보세요.

1 #include <iostream>

3 class MyArray

4 {

5 public:

6 MyArray(int size) : m_pArr(new int[size]), m_size(size)

7 {

8 for(int i = 0; i < m_size; i++)

9 m_pArr[i] = i;

10 }

11 //Copy constructor

12 MyArray(const MyArray& other) : m_pArr(new int[other.m_size]), m_size(other.m_size)

13 {

14 for(int i = 0; i < m_size; i++)

15 m_pArr[i] = other.m_pArr[i];

16 }

18 //Move constructor

19 MyArray(MyArray&& other) : m_pArr(other.m_pArr), m_size(other.m_size)

20 {

21 other.m_pArr = NULL;

22 }

23 ~MyArray()

24 {

25 delete [] m_pArr;

26 }

29 private:

30 int* m_pArr;

31 int m_size;

33 };

move 생성자는 훨씬 간단하네요. 새롭게 메모리를 할당할 필요도 없고요.

우리가 move 생성자에서 눈여겨 봐야 할 것이 두 가지 있습니다.

1. 바디 내에서 other.m_pArr 을 NULL 로 셋팅하고 있습니다.

2. 파라미터가 const 타입이 아닙니다.

먼저 첫번째로 other.m_pArr 을 NULL 로 셋팅하는 이유를 봅시다. other 객체도 언젠가는 (scope 을 벗어날때) 소멸되는 임시 객체입니다. 이 객체가 소멸하는 순간 당연히 소멸자가 불립니다. 소멸자를 보시면 m_pArr 을 삭제하는 루틴이 있는 것을 알 수 있습니다.

move semantics에서 m_pArr 은 이미 다른 인스턴스에게 소유권이 이전된 메모리 영역입니다. 따라서 other.m_pArr 을 NULL 로 셋팅해주지 않는다면 다른 인스턴스 (this) 에게 이미 소유권이 넘어간 m_pArr을 delete 하게되고, 이는 당연히 move를 호출한 해당 인스턴스 (this) 가 가지고 있는 m_pArr을 삭제하는 결과를 초래하게 됩니다. 이는 마치 deep-copy 가 아닌 shallow-copy 와 마찬가지 상황인 것입니다. 따라서 other.m_pArr 을 NULL 로 셋팅해주는 이유는, 소멸자에서 delete[] m_pArr 이 호출되는 것을 방지하기 위함입니다.

두번째로 파라미터가 const 타입이 아닌 것은 너무나 당연합니다. 내부에서 other 의 멤버인 m_pArr을 수정해야 하니까 말이죠. const 면 건드릴 수 조차 없겠죠?

Performance

이제, move constructor 의 수행성능을 한번 봅시다.

35 #include <ctime>

37 int main()

38 {

39 MyArray a(100000000);

42 //Copy constructor

43 clock_t ct1 = clock();

44 MyArray myCopy(a);

45 clock_t ct2 = clock();

46 double msec1 = 1000.0 * (ct2-ct1) / CLOCKS_PER_SEC;

47 std::cout<<"Copy time: "<<msec1<<" msec"<<std::endl;

50 //Move constructor

51 clock_t mt1 = clock();

52 MyArray myMove(std::move(a));

53 clock_t mt2 = clock();

54 double msec2 = 1000.0 * (mt2-mt1) / CLOCKS_PER_SEC;

55 std::cout<<"Move time: "<<msec2<<" msec"<<std::endl;

57 return 0;

58 }

59 /*

60 Output:

61 Copy time: 343 msec

62 Move time: 0 msec

63 계속하려면 아무 키나 누르십시오 . . .

64 */

유의미한 값을 얻기 위해 1억개의 정수배열을 가지고 테스트해보았습니다만, 그 차이가 실로 엄청나네요.

move 의 경우 거의 시간이 걸리지 않는 것을 알 수 있습니다.

유사한 다른 예제코드도 한번 보죠.

내부적으로 vector 를 멤버로 가지고 있는 클래스에서 각각 copy constructor 와 move constructor 를 이용했을때의 속도차를 살펴보았습니다. VC++10.0 (VS2010) 에 포함된 C++ 라이브러리는 STL에 이미 move semantics가 구현되있다는 것을 잊지마세요.

이말은 STL 컨테이너인 vector에도 move constructor 나 move assignment operator 가 구현되어있다는 의미입니다.

1 #include <vector>

2 #include <ctime>

3 #include <iostream>

4 class X

5 {

6 private:

7 std::vector<int> m_vec;

9 public:

10 X() : m_vec(100000)

11 {

12 for(size_t i=0; i < 100000; ++i)

13 m_vec[i] = i;

14 }

16 //copy constructor

17 X(const X& other) : m_vec(other.m_vec){}

19 //move constructor

20 X(X&& other) : m_vec(std::move(other.m_vec)){}

22 X& operator=(const X& other)

23 {

24 m_vec = other.m_vec;

25 return *this;

26 }

28 X& operator=(X&& other)

29 {

30 m_vec = std::move(other.m_vec);

31 return *this;

32 }

33 };

35 int main()

36 {

37 X x1;

39 //check copy time

40 clock_t ct1 = clock();

41 X x2(x1);

42 clock_t ct2 = clock();

43 double msec = 1000.0 * (ct2-ct1) / CLOCKS_PER_SEC;

44 std::cout<<"Copy time: "<<msec<<" msec"<<std::endl;

46 //check move time

47 clock_t mt1 = clock();

48 X x3(std::move(x1));

49 clock_t mt2 = clock();

50 double msec2 = 1000.0 * (mt2-mt1) / CLOCKS_PER_SEC;

51 std::cout<<"Move time: "<<msec2<<" msec"<<std::endl;

53 return 0;

54 }

56 /*

57 output:

59 Copy time: 46 msec

60 Move time: 0 msec

62 */

역시 굉장한 차이를 보여주고 있고, 특히 move constructor 의 경우 거의 시간이 걸리지 않는 다는 것을 다시 한번 알 수 있습니다.

소프트웨어 2011

In search of dream 꿈찾아고고씽 — Wed, 21 Dec 2011 00:59:19 +1100

2011년 한해 즐겨사용했던 소프트웨어 목록을 정리해봅니다.

저의 미디어 소비방식을 통째로 바꿔놓았던 iTunes.

애플 팬보이가 될 줄은 꿈에도 몰랐는데, 안드로이드로 기변한 지금까지도 여전히 iTunes 를 사용한다는.

현존하는 최고의 멀티미디어 플랫폼이 아닐까 싶습니다.

이젠 망하면 어쩌나 걱정이 될 정도로, 오랫동안 사용해왔던, 나의 노트 클리핑 어플리케이션.

역시 용량면에서는 스카이드라이브를 따라갈 만한게 없었죠. 25G

클라우드 스토리지의 새로운 강자.

간단한 파일 공유는 드랍박스가 최고.

집중해서 글을 써야할 때는 다크룸.

간단한 이미지 편집툴.

뭔가 숨기고 싶을때 유용한 툴.

여기 없으면 개발 못합니다. ㅋㅋ

위키 방식 오픈소스 프로젝트 매니지먼트 툴.

Continuous Integration !

Visual Studio 애드온 Subversion 클라이언트.

요즘 뜨는 git. Visual studio 용 애드온.

코딩도 이젠 소셜하게...

말이 필요없는 이클립스. 개인적으론 파이썬 쓸 때 감사히 사용하는 툴.

괜찮은 마인드 맵 유틸.

C++11 스터디 노트 (12/n) - move semantics (1)

In search of dream 꿈찾아고고씽 — Mon, 19 Dec 2011 12:25:14 +1100

이번 포스트는 move semantics 에 대한 첫번째 포스트입니다.

이 글에서는 move semantics에 대해 이야기 하기 전에, C++ 복사(copy)가 가진, C++ copy semantics가 가지고 있는 문제점에 대해서 우선 생각해봅시다. 왜냐면 move semantics 가 등장한 배경에는 C++ copy 에 대한 고민이 있었기 때문입니다. 문제점을 인식하지 못한다면, 왜 이걸 해야하는지 동의하기도 힘드니까요.

C++ 에서는 어느 한 객체의 상태를 다른 객체로 복사하는 일이 가능합니다.

C++ 에서 복사와 관련된 메커니즘은 Copy Constructor 와 Assignment Operator 에 의해 처리됩니다. 이 둘은 프로그래머가 정의할 수도 있고, 컴파일러에 의해 정의되기도 합니다. 만약 컴파일러가 클래스 내에서 이 둘을 찾을 수 없다면 자동적으로 이를 생성해 주도록 되어있기 때문입니다. 하지만, 클래스 내부에서 다른 타입의 리소스를 가지고 뭔가 한다면, deep copy를 위해 프로그래머가 직접 정의한 copy con 과 asgn oprt 가 있어야 하는 것이 best practice 입니다.

이 둘의 전형적인 구현 패턴은 매우 유사합니다.

1. 멤버 변수를 위해 새로 리소스를 할당해 주고

2. 인자로부터 this 포인터로 복사를 실행하고

3. 기존 리소스를 해제한 후

4. 해제된 기존 리소스에 새로운 리소스를 할당하여 이를 반환합니다.

이는 마치 디카에 있는 SD 메모리카드에서 컴퓨터로 사진을 옮기는 시나리오와 비슷합니다.

1. 우선 사진 복사를 위해 PC 에 폴더를 하나 만듭니다.

2. 이제 SD 카드에서 사진들을 선택해 컴퓨터로 복사합니다.

3. 복사가 끝나면, SD 카드의 해당 원본 사진들을 삭제하기 시작합니다.

4. 삭제가 끝나면, 이제 PC에서 복사한 사진을 가지고 작업을 시작합니다.

이 글을 읽으시는 분 들 가운데 설마 이렇게 하는 분들은 없으시겠죠? ^^

하지만 놀랍게도, C++ 의 메커니즘과 위의 비효율적인 디카 사진 옮기기 시나리오는 거의 동일합니다.

Q) 그럼, 디카 사진은 어떻게 옮겨야 됩니까?

A) 그냥 ctrl + c, ctrl + v 하면 됩니다.

Q) 그럼 C++ 에서는요?

A) 그냥 닥치고 하던 대로 하세요. ㅠ,.ㅠ

우리는 여태까지 C++ 세상에서 이렇게 비효율적으로 살아왔다는 불편한 진실. ^^;;

이러한 C++ 언어의 기능(제한)적인 측면은 STL의 구현에도 지대한 영향을 미쳤더랬습니다.

가령 예를 들어, vector 안에 어떤 객체를 넣는 오퍼레이션을 생각해보죠.

1 #include <vector>

2 class MyClass;

4 void foo()

5 {

6 MyClass o;

7 std::vector<MyClass> vec;

8 // ...

9 // ... vec에 대한 뭔가 많은 오퍼레이션 ...

10 // ...

11 vec.push_back(o);

12 }

만약 라인8 부터 10까지의, 뭔가 많은 오퍼레이션으로 인해, vec.push_back(o); 라인을 만나기 전에 vec이 모두 채워져 버렸다고 가정해봅시다. vector는 동적으로 증가하는 배열입니다. 그렇기 때문에 벡터가 꽉 차버리는 경우, 컴파일러 내부적으로 아래와 같은 일들이 벌어집니다.

1. 크기가 더 큰 새로운 vector 를 만들고 (STL 구현 벤더에 따라 다릅니다만, 보통 1.5 ~ 2 배 씩 그 크기가 증가하는 것으로 알려져 있습니다.)

2. 이곳에 기존벡터에 있던 엘리먼트들을 모두 복사합니다.

3. 복사가 모두 끝나면, 기존 벡터안에 있던 엘리먼트들을 모두 파괴시킵니다. 벡터 내부 엘리먼트가 객체인 경우엔 객체의 소멸자를 호출합니다.

4. 기존 벡터 자체를 파괴시킵니다.

5. 새로운 벡터의 이름을 기존 벡터 이름으로 바꿔치기 합니다.

위의 모든 과정이 끝나고 나서야, 이제 vec.push_back(o); 가 실행됩니다.

프로그래머: "전 그냥 벡터 끄트머리에 객체 2개만 더 추가하고 싶었을 뿐이라고요..."

컴파일러: "닥치세요. 2개던 100개던 상관없어. 난 저렇게 밖에 할 줄 모르거든!"

다른 예로, 벡터를 반환하는 팩토리 함수도 한번 생각해봅시다.

1 #include <vector>

2 class MyClass;

3 typedef std::vector<MyClass> MyVec;

5 MyVec createMyVec(); // 팩토리 함수

6 void foo()

7 {

8 MyVec vec;

9 //...

10 //... vec을 이용한 다양한 오퍼레이션 ...

11 //...

12 vec = createMyVec();

13 }

8 라인이 실행되면, 우선 STL 구현에 따라 정의된 디폴트 사이즈로 vector가 생성됩니다. 다음에 vec을 이용해서 뭔가 다양한 일들을 수행합니다. 그리고, 12 라인이 실행되면 다음과 같은 일이 벌어집니다.

1. createMyVec() 은 내부에서 임시로 비어있는 MyVec 객체를 하나 만들고 (vec2 라고 합시다),

2. createMyVec() 함수 안에서 정의된 일을 수행한 후,

3. vec2를 vec 에 대입합니다.

3번 과정의 내부를 좀 더 들여다 봅시다.

3-1) createMyVec() 함수가 반환할 때 우선 넘겨받아야 할 vec 에 빈 자리가 있어야 하므로,

3-2) vec이 가지고 있던 엘리먼트들을 파괴합니다. vec 안에 무엇이 들어있던 간에 파괴됩니다.

3-3) vec 내부 확보가 끝나면, vec2 내의 엘리먼트를 vec 으로 하나 하나 복사합니다.

3-4) 복사를 모두 마치면, vec2는 소멸되어야 하므로, vec2 내부에 들어있는 엘리먼트를 파괴합니다.

3-5) vec2 의 엘리먼트들이 모두 소멸되고 난 후에, vec2를 소멸합니다

이제 어느 정도 C++ Copy Semantics 가 가지고 있는 문제점에 대해 인식이 되셨나요?

C++11 에서는 copy의 이러한 비효율을 없애기 위해 move semantics 라는 개념을 들고 나왔고, 더불어 C++ STL 에도 이런 메커니즘을 대거 적용했습니다.

이로 인해, 심지어! 기존 레거시 코드의 퍼포먼스도 향상되었고요.

이런 일이 가능했던 것은 모두 다 r-value 레퍼런스라는 명품조연 덕분입니다.

다음 포스트에는 move semantics 가 어떻게 생겼는지 알아보도록 하겠습니다.

Tahlee and Terrigal Family & Friends Out Pics

In search of dream 꿈찾아고고씽 — Thu, 15 Dec 2011 00:09:02 +1100

C++11 스터디 노트 (11/n) - R-Value Reference

In search of dream 꿈찾아고고씽 — Tue, 13 Dec 2011 21:45:47 +1100

이번 포스트에서는 R-Value 레퍼런스에대해 알아보도록 하겠습니다. R-Value 에 대해 이야기하기 전에 먼저 기존 C++의 레퍼런스 타입에 대해 잠깐 리마인드 해보고 넘어갑시다.

1 MyClass a;

3 MyClass& b = a;

이미 알고 계시듯이 a 라고 객체를 하나 만들었고, b 라는 레퍼런스 타입을 하나 만들어서 a를 참조하도록 하고 있습니다. 이때 b 를 레퍼런스 밸류라고 불러왔었습니다.

하지만, C++11이 나온 이제부터는 b 값의 타입을 레퍼런스라고 부르지 마세요. 대신 L-Value 레퍼런스라고 불러야 합니다. 이게 다 R-Value 레퍼런스가 나온 덕분입니다.

새로운 C++ 표준에서 레퍼런스라는 개념은 L-Value 레퍼런스와 R-Value 레퍼런스로 나뉘어집니다. 이제부터 여러분의 팀원이 뭐시기 뭐시기는 레퍼런스 타입이라고 하면 이제부터는 L-Value 인지 R-Value 인지 다시 한번 물어보도록 합시다.

그럼 R-Value 레퍼런스는 얼마나 이쁘게 생겼는지 한번 봅시다.

1 MyClass a;

3 MyClass&& c = a;

위 코드에서 c가 R-Value 레퍼런스 타입 변수입니다. 이게 뭔가요. &&를 붙이는 것만 빼고는 똑같군요.

흠. 좀실망인데요.

하지만, 맞습니다. R-Value 레퍼런스는 L-Value 레퍼런스랑 한 가지만 빼고 똑같습니다. ( 아, &를 하나 더 붙이는거까지 합치면 두 개군요.)

L-Value 레퍼런스는 그 우측값(r-value)으로 L-Value 만 받을 수 있습니다. 그에 반해 R-Value 레퍼런스는 그 우측값(r-value) 로 L-Value 뿐만 아니라 R-Value 도 받을 수 있습니다.

헷갈리나요? 헷갈리는 분들은 L-Value 와 R-Value 에 대한 정의가 명확하시지 않으셔서 그럴겁니다. L-Value/R-Value 가 뭐였는지 다시 한번 되집어 볼까요?

C 표준에서는 이 둘을 아래와 같이 정의합니다.

An L-Value is an expression e that may appear on the left or on the right hand side of an assignment, whereas an R-Value is an expression that can only appear on the right hand side of an assignment

해석하면, 대입식 (assignment) 에서 왼쪽 또는 오른쪽에 나올 수 있는게 L-Value (left-hand side value의 약자), 오른쪽에만 나올 수 있는게 R-Value (right-hand side value의 약자) 입니다. 뭔가 성의없어 보이는 설명에 더 헷갈리기만 하는군요. 어쩔 수 없네요. 예를 들어 봅시다.

1 int a = 13;

3 int b = 12;

a 와 b는 L-Value 이고, 13 과 12는 R-Value 입니다. L-Value는 오른쪽에도 나올 수 있다고 했습니다. 즉, L-Value 가 R-Value가 필요한 자리에 나오면, L-Value는 묵시/자동적으로 R-Value 로 변경됩니다. 따라서

5 a = b; //ok

6 b = a; // ok

7 a = a*b; //ok

는 모두 가능합니다.

위에서 a*b 는 R-Value 입니다. 따라서 ,

9 int c = a*b; // ok

10 //a*b = 12; // error. R-Value must be on the right side.

앞에서 R-Value가 필요한 자리에 L-Value가 나오면, 묵시/자동적으로 R-Value 로 변경된다고 했는데요. R-Value는 그게 안됩니다. R-Value는 무조건 R-Value 자리에 있어야 됩니다. R-Value 는 대입식의 오른쪽이 지정석입니다. 지정석 외에 다른 자리에 앉으면 안됩니다.

또한 위 코드에서 모든 변수들에 const 를 붙여주지 않았기 때문에, L-Value 는 처음 정의가 된 이후에, R-Value를 통해 변경이 가능합니다. 이에 반해 R-Value 는 변경이 되지 않습니다. R-Value 는 굳이 const로 지정해주지 않아도 const 의 성격을 가지고 있습니다.

C의 L-Value / R-Value 정의는 C++ 에서도 여전히 유효합니다만, 이렇게 이해하는 것이 더 좋을겁니다.

특정 메모리 위치를 가르키고 있으며, 어떤 값을 assign 할 수 있고, & 오퍼레이터를 통해 해당 메모리의 주소값을 가져올 수 있는 expression 이 L-Value 입니다. R-Value는 L-Value 가 아닌 expression 입니다.

즉, 값을 담을 수 없으며 (can't assign) , L-Value 에 값을 담기 위해 임시(temporary)로 생성된 expression 입니다. 값을 담을 수 없기 때문에 당연히 & 오퍼레이터를 써서 그 내부의 값을 알아오는 것도 불가능합니다.

하나 더.

C++에서 레퍼런스 타입을 반환하는 함수에 대한 호출은 L-Value를 반환하고, 이를 제외한 함수는 모두 R-Value를 반환합니다. 즉,

12 int& foo();

13 foo() = 12; // ok

14 int* p1 = &foo(); // ok

foo() 함수 호출은 L-Value를 반환하고, L-Value 는 & 연산자를 통해 주소값을 가져올 수 있습니다.

16 int bar();

17 int j = 0;

18 j = bar(); // ok. bar() is R-Value

19 // int* p2 = &bar(); // error. R-Value can't be applied & operator.

이제 R-Value 와 L-Value의 차이가 이해가 되시나요?

자. 그럼, R-Value 레퍼런스. 도.대.체 이걸 왜 알아야 되는 걸까요. 이게 왜 필요한 걸까요? 이런 간략한 변화따위로 우리 디벨로퍼들 인생을 편하게 해줄 수 있을까요?

그 이유는 R-Value 레퍼런스를 사용해야 C++11에 새롭게 도입된 move semantics 를 구현할 수 있었기 때문입니다. 또한 R-Value 레퍼런스는 역시 C++11에 새롭게 등장한 perfect forwarding 또한 해결할 수 있는 키를 쥐고 있는 개념입니다. 무대의 여배우를 화려하게 빛나게 해주기 위한 명품조연이라고나 할까요.

L-Value 와 R-Value의 차이를 정확히 이해하고 있어야, 앞으로 등장할 move semantics 와 perfect forwarding의 개념을 쉽게 이해할 수 있습니다. 그 중에서도 move semantics 은 정말 C++ 11에서 람다함수만큼이나 천지가 개벽할 만한 내용입니다. 물론 이걸 안다고 해서 하늘에서 돈다발이 쏟아져 내리는 건 아닙니다만, 엄청나게 훌륭한 개념이긴 합니다. C++ 코드의 성능도 좋아지고, 남들 앞에서 조금 아는척도 하실 수 있을거고요. ^^

암튼, R-Value와 L-Value 가 조금 헷갈리더라도 정확히 알고 넘어가야 합니다.

이제까지의 내용을 정리해서 코드로 만들어봤습니다. 설명은 코드 안에 커멘트형식으로 달아두었습니다. 우스운 영어실력이긴하지만, ^^ 이해하기 어렵지는 않으실거예요.

1 #include <iostream>

3 int main(int argc, char** argv)

4 {

5 using namespace std;

7 //L-Value Reference you're familiar since C++98

8 int a = 1;

9 //int& r = 3; //error as L-Value reference can only have

10 // L-Value as its R-Value

11 int& ra = a;

13 cout<<"Original: L-Value(a): "<<a<< ", L-Value Reference(ra): "<<ra<<endl;

14 ra = 2;

15 cout<<"Modified: L-Value(a): "<<a<< ", L-Value Reference(ra): "<<ra<<endl;

17 //newly introduced R-Value Reference in C++11

18 int b = 10;

19 int&& rb = 20; //no error as R-Value reference can have

20 // either L-Value or R-value as its R-Value

22 cout<<"Original: L-Value(b): "<<b<< ", R-Value Reference(rb): "<<rb<<endl;

23 rb = b;//Now R-value reference is assigned by L-Value

24 cout<<"Modified: L-Value(b): "<<b<< ", R-Value Reference(rb): "<<rb<<endl;

26 return 0;

27 }

실행결과입니다.

R-Value 레퍼런스를 활용한 move semantics 와 perfect forwarding 에 대한 개념은 이어지는 포스트에서 다루겠습니다. 이제까지는 밑밥이었습니다. 본격적으로 재밌는 이야기는 다음편에 ^^;;

C++11 스터디 노트 (10/n) - static_assert

In search of dream 꿈찾아고고씽 — Mon, 12 Dec 2011 10:56:54 +1100

이번 포스트에서는 C++11에 새롭게 도입된 static_assert라는 키워드에 대해 알아봅니다. 먼저 이 키워드의 용도는 컴파일 타임에 어떤 주어진 조건을 검사하는데 사용합니다. Syntax 는 아래와 같습니다.

static_assert(expression, message)

expression 이 true 로 판명되면, 컴파일러는 아무것도 안합니다. false 로 판명되면 C2338 에러를 뿜고, 두번째 파라미터로 넘겨준 message를 출력합니다.

1 #include <iostream>

3 int main()

4 {

5 const auto MAX_LEVEL = 120;

6 static_assert(MAX_LEVEL <= 100, "Warning - Max Level"); //error C2338: Warning - Max Level

7 return 0;

8 }

문법과 사용법 자체는 크게 어려운게 없습니다.

활용예를 생각해봅시다.

멀티 플랫폼을 위한 어플리케이션 작성에 활용해 볼 수 있겠습니다.

1 #include <iostream>

3 int main()

4 {

5 //...

6 static_assert(sizeof(void*) == 4, "This code is not supported for 64bit");

7 //...

8 return 0;

9 }

포인터의 크기는 32 비트 머신에서는 4이지만, 64비트 머신에서는 8입니다. 플랫폼의 크기에 따라 다른거죠.

위 코드는 만약 32 비트 머신에서 컴파일하면 아무런 에러가 없지만, 64비트 머신에서 컴파일하면 마찬가지로 C2338 에러를 냅니다. 이 코드는 해당 코드의 빌드 머신 플랫폼을 체크할때 사용할 수 있겠네요.

static_assert 는 클래스 내에 삽입할 수도 있습니다. 가령 아래와 같은 템플릿 코드 내에서 static_assert를 삽입하여, 입력되는 값을 컨트롤 할 수도 있겠습니다.

1 #include <iostream>

3 template <int N>

4 struct MyStruct

5 {

6 static_assert(N < 10, "MyStruct requires N < 10");

7 };

9 int main()

10 {

11 MyStruct<1> m1;

12 MyStruct<5> m2;

13 MyStruct<9> m3;

14 MyStruct<13> m4; // error C2338: MyStruct requires N < 10

16 return 0;

17 }

다른 예로, 여러분이 라이브러리 개발자라고 해봅시다. 예전 버전에서 A라는 클래스를 쓰고 있었는데, 문제가 발견되어 A 클래스를 A2 클래스로 바꿨습니다. 예전 버전과의 호환성 문제때문에 A 클래스는 지워버릴 수가 없는 상황입니다.

다른 팀에 있는 개발자들에게 회의나 이메일 등을 통해 "A 클래스는 예전 버전을 위한 코드이니, 내일부터는 A2 클래스를 써주세요" 라고 알려줬지만, 죽어라고 말 안듣고 계속 A 클래스를 사용하고 있어서 그로 인한 문제가 QA 로부터 계속해서 터져나오는 상황입니다.

이럴 때는 A 클래스 내에 static_assert를 삽입하여, 코드 내부에서 좀더 명확히 해줄 수도 있겠습니다.

1 class A

2 {

3 public:

4 A(){};

5 ~A(){};

6 static_assert(0, "don't use this class A - deprecated. Use A2 instead");

7 // ...

8 };

10 class A2

11 {

12 public:

13 A2(){}

14 ~A2(){}

15 // ...

16 };

18 void Test()

19 {

20 A a;//error C2338: don't use this class A - deprecated. Use A2 instead

21 //...

22 }

24 int main()

25 {

26 //...

27 Test();

28 // ...

29 return 0;

30 }

라인 6을 보면, 예전 클래스인 A 클래스 내부에, static_assert 를 삽입하고, 파라미터로 조건은 무조건 false 가 리턴되도록 0을 주고, 적절한 메시지를 줬습니다.

18 라인의 Test() 라는 함수에서 또 A 클래스를 쓰려고 시도합니다만, 이제는 C2338 에러를 내면서 A2 클래스를 써야 한다고 메시지 창에 보여줍니다.