Search

'Visual C++ 10'에 해당되는 글 59건

  1. 2011.08.15 C++0x가 드디어 C++11이 되었습니다.
  2. 2011.07.04 [StartD2D-4] WIC 를 이용한 이미지 작업하기 3
  3. 2011.06.21 [STL] 15. VC++ 10에 추가된 새로운 컨테이너 forward_list – 사용편
  4. 2011.06.14 [STL] 14. VC++ 10에 추가된 새로운 컨테이너 forward_list – 소개편 1
  5. 2011.05.30 [STL] 13. <algorithm>에 추가된 새로운 함수들 minmax_element
  6. 2011.05.19 [STL] 12. <algorithm>에 추가된 새로운 함수들 iota
  7. 2011.05.11 [STL] 11. <algorithm>에 추가된 새로운 함수들 is_heap, is_heap_until
  8. 2011.04.25 [STL] 10. <algorithm>에 추가된 새로운 함수들 is_sorted, is_sorted_until 1
  9. 2011.04.19 [STL] 9. <algorithm>에 추가된 새로운 함수들 is_partitioned, partition_point 1
  10. 2011.04.12 [STL] 8. <algorithm>에 추가된 새로운 함수들 - partition_copy 2
  11. 2011.03.07 [SafeInt] C++에서 안전한 정수 연산을 하자 - 4
  12. 2011.03.02 [SafeInt] C++에서 안전한 정수 연산을 하자 - 3 5
  13. 2011.02.22 [SafeInt] C++에서 안전한 정수 연산을 하자 - 2
  14. 2011.02.14 [SafeInt] C++에서 안전한 정수 연산을 하자 - 1
  15. 2011.01.31 [Step. 25] 닷넷에서 HalfNetwork를 사용하자 – 6(마지막) 4
  16. 2011.01.24 [Step. 24] 닷넷에서 HalfNetwork를 사용하자 – 5 2
  17. 2011.01.17 [Step. 23] 닷넷에서 HalfNetwork를 사용하자 – 4 3
  18. 2010.12.30 [Step. 21] 닷넷에서 HalfNetwork를 사용하자 - 2
  19. 2010.12.27 [Step. 20] 닷넷에서 HalfNetwork를 사용하자 - 1 2
  20. 2010.11.17 [Step. 17] 델리게이트에 비관리 함수를 할당하기 그리고 다음 예고 2

C++0x가 드디어 C++11이 되었습니다.

C++0x 2011. 8. 15. 16:02 Posted by 알 수 없는 사용자

새로운 C++ 표준 작업이 언제쯤에나 끝날지 고대하고 있는 분들에게 반가운 소식이 있습니다.

드디어 C++0x 작업이 거의 마무리 되었습니다.

 

저번 주 수요일에 최종 국제 투표가 끝난 후 드디어 결과가 나왔는데 만장 일치로 승인이 되었습니다. 이제는 앞으로 몇 달 후에 ISO로부터 최종 발행만 기다리면 됩니다(즉 서류적인 절차만 남았습니다).

 

이로써 길게 길게 진행된 C++의 새로운 표준 작업은 끝나게 되어서 이제 C++11로 불리게 되었습니다( 이전에는 C++98, C++03이 있었습니다 ).

 

C++은 특정 회사가 주도하지 않고, 기존에 C++로 만들었던 코드가 문제 없이 동작해야 하고(표준 사양만 지켰다면), 성능과 편리성을 모두 가지려고 하니 많은 시간이 걸렸습니다.

 

아직 ISO에서 최종 문서가 나오지 않았고 무료로 최종 사양이 어떻게 되었는지 궁금한 분들은 http://t.co/5mjCzyJ 를 통해서 문서를 받아보기 바랍니다. 이 문서는 워킹 드래프트 3242 ISO에서 나올 사양 문서와 거의 같을 것입니다(참고로 ISO에서 나온 문서는 유료입니다).

 

이제 우리는 앞으로 나올 Visual C++이 과연 얼만큼 새로운 표준 기능을 구현해 줄지가 기대됩니다. 개인적으로 꽤 많은 부분이 구현되리라 생각하고 혹 빠진 부분은 예전의 tr1처럼 서비스 팩에서 구현되지 않을까 생각합니다.

 

C++ 새로운 표준이 정해졌으니 남보다 앞서기를 바라는 C++ 프로그래머들은 새로운 C++ 표준을 공부해 봅시다. ^^

 

근래에 바빠서 글을 거의 올리지 못했는데 다음 글은 새로운 C++ 표준의 바뀐 부분을 간단하게 설명하는 글을 올릴 예정입니다.

그리고 새로 추가되는 표준 라이브러리는 boost 라이브러리에서 많이 들어왔습니다. 그래서 지금이라도 boost 라이브러리를 다운로드 받으면 새로운 표준에 들어갈 라이브러리를 미리 사용할 수 있습니다.

 

 


참고

C++0x 사양

위키피디아

http://en.wikipedia.org/wiki/C%2B%2B0x

GCC feature 테이블

http://gcc.gnu.org/projects/cxx0x.html

 

boost 라이브러리

설치 버전 다운로드

http://www.boostpro.com/download/

공식 홈페이지

http://www.boost.org

 

 

 

[StartD2D-4] WIC 를 이용한 이미지 작업하기

DirectX 11 2011. 7. 4. 08:30 Posted by 알 수 없는 사용자

 

  

이번 시간에는 직접 이미지를 화면에 표현하는 방법에 대해서 언급합니다.

Win32 API를 이용할 때, 우리는 '비트맵(Bitmap)' 이라는

그래픽 데이터 포맷을 읽어서 화면에 그려주었습니다.

사람마다 차이는 있겠지만, 일반적으로 다음과 같은 순서를 따라서 구성했을 것입니다.

 

  1. 비트맵을 읽기 위해서 파일을 오픈한다.

  2. 파일에서 헤더를 읽어 들인다.


  3. 비트맵 헤더의 정보를 통해서 관련 메모리를 생성하고,

    파일에서 색상 데이터에 대한 정보를 읽는다.


  4. DIBSection 을 생성하고, 실제 데이터를 읽는다.
  5. 그리고 마무리 한다.

 

이 순서는 수 많은 방법 중에 하나일 뿐이지만,

기본적으로 파일을 열어서 헤더를 먼저 읽고, 관련 메모리를 생성하고,

이후에 실제 데이터를 채우게 되는 순서는 공통된 작업입니다.

Direct2D 에서도 이와 같이 작업을 해도 되지만,

이미 편의를 위해 만들어진 라이브러리를 사용해서 조금 더 확장성 있는 작업을 할 필요가 있습니다.

지금부터는 WIC를 이용한 간단한 이미지 뷰어 작업을 해보겠습니다.

  

WIC( Windows Imaging Component )

 

DirectX 가 윈도우 운영체제 전반으로 광범위하게 활용되면서,

이들과 관련한 내용들을 분리할 필요가 있었습니다.

과거까지는 DirectX 는 게임 개발자들의 전유물에 가까웠기 때문에,

다른 개발자들도 손쉬운 개념으로 접근할 수 있는 그런 분류가 필요했습니다.


결과적으로 아래와 같이 분류가 되었습니다.  

 

WIC는 모든 이미지를 쉽게 처리할 수 있도록 만들어낸 COM 기반의 프레임워크입니다.

그림에서 보듯이 WIC도 하나의 큰 영역으로서 자리 잡고 있습니다.

( 참고로 DXVA는 영상 처리를 위한 프레임워크입니다. )

 

WIC를 이용한 이미지 처리는 앞서 GDI 기반에서 작성했던 것과는 완전히 다릅니다.

WIC는 PNG, JPG, GIF 등과 같은 거의 모든 주요한 이미지 형식을 포함하고,

기본 코덱들을 지원하고 있습니다.

 

말이 참 어렵죠?

쉽게 말해서, Direct2D 기반에서 이미지 처리를 하려면 WIC를 사용하면 쉽게 할 수 있다는 것입니다.

우리는 이것을 사용하는 순서와 방법에 대해서 배우기 위해서,

윈도우 화면에 이미지를 그려주는 간단한 애플리케이션을 만들어 볼 것입니다.

 

 

기본 WIC 프로그래밍

 

애플리케이션 마법사로 새로운 프로젝트를 만들고, stdax.h 에 다음을 추가를 합니다.

 

'WindowsCodecs.lib'와 'wincodec.h' 가 바로 WIC를 사용하기 위해 추가시킨 것입니다.

눈치 빠른 분들이라면, 이름에서 약간 앞으로의 작업 방향을 예측할 수 있을 것입니다.

 

이번 프로젝트에서 사용할 전역 변수들은 아래와 같습니다.

 

 

익숙한 개념이 눈에 보이지 않으십니까?

바로 IWICImagingFactory 입니다. 네 그렇습니다~

WIC 도 바로 팩토리 형태로 생성이 됩니다.

 

추가된 변수들은 아래와 같은 절차에 의해 값이 채워집니다.

즉, 아래는 WIC의 처리 과정입니다.

 

  1. WIC 팩토리를 만든다.

  2. 파일 경로를 기반으로 해서 디코더를 만든다.

  3. 디코딩된 프레임을 가져온다.

  4. 변환기에 넣어서 Direct2D 형식으로 변환한다.

  5. Direct2D 비트맵을 생성하고, 이를 렌더링한다.

 

이제 위의 절차를 실제로 어떻게 처리하는지를 차근차근 살펴보겠습니다.

 

가장 먼저하는 초기화 작업입니다.

앞서 언급했듯이, WIC 도 팩토리 개념으로 생성됩니다.

COM 기반이기 때문에 API 인자들이 굉장히 어려워 보일 수도 있지만, 관심을 둘 부분은 아닙니다.

위와 같은 방법으로만 하면, WIC가 생성 되어진다는 개념으로만 인식하고 다음 단계로 넘어갑니다.

 

 

 

다음 단계는 디코더를 만들고, 이를 기반으로 해서 Direct2D 형식으로 데이터를 변환하는 것입니다.

이를 위해서 가장 먼저 해야 하는 일은

이미지를 읽어들이기 위한 디코더( Decoder )를 만드는 일입니다.


갑자기 등장한 생소한 용어에 조금 혼란스러울 것 같습니다.

우리가 사용하는 모든 멀티미디어 파일( 이미지, 영상, 사운드 등 )들은

굉장히 어려운 방법으로 압축이 되어있습니다.


이들에 대한 원리나 형식을 이해하는 것도 중요한 일일 수도 있지만,

이는 간단하게 본 페이지에서 설명할 수 있는 내용이 아닙니다.

물론 저도 이와 관련한 전문가는 더더욱 아닙니다.

우리는 단지 API만으로 이들에 대한 고민을 해결할 수 있습니다.

바로 그것이 WIC의 존재 이유 중 하나 일 것입니다.^^

 

즉, 우리는 이미 만들어진 API를 이용해서 손쉽게 이미지 파일을 읽어올 수 있습니다.

그런 역할을 하는 것이 바로 디코더입니다.

아래는 디코더를 가지고 실제 작업을 하는 부분입니다.

 

 

디코더는 WIC 팩토리 멤버함수로써 생성이 되어집니다.

우리가 사용했던 이 API의 원형은 다음과 같습니다.

<코드>

HRESULT CreateDecoderFromFilename(

[in] LPCWSTR wzFilename,

[in] const GUID *pguidVendor,

[in] DWORD dwDesiredAccess,

[in] WICDecodeOptions metadataOptions,

[out, retval] IWICBitmapDecoder **ppIDecoder

);

</코드>

 

이 API는 주어진 이미지 파일을 기반으로 해서 디코더를 생성해 줍니다.

첫 번째 인자로 파일명이 들어갑니다.

이 파일을 기반으로 해서 적합한 디코더를 생성해 주게 되는 것입니다.

예를 들어, PNG 파일이면 PNG에 대한 디코더가 필요하다고 인식하고,

그에 맞는 디코더를 자동적으로 생성해 주는 것입니다.

 

두 번째 인자는 선호하는 디코더 벤더(vendor)의 GUID를 입력해야 하는데, 지금은 NULL을 사용합니다.

 

세 번째 인자로는 디코더에 대한 접근 방법을 명시합니다.

읽기(read), 쓰기(write), 혹은 둘 다 가능한지를 넣어주면,

가장 최적화된 방법과 메모리 위치를 가지는 디코드를 생성해 줍니다.

위의 예제에서는 읽기용으로만 디코더를 만들었습니다.

 

네 번째 인자는 디코더의 캐시 관련 옵션입니다.

우리가 인자로 넘긴 WICDecodeMetadataCacheOnDemand는

필요한 이미지 정보만 캐시 하도록 옵션을 준 것입니다.

다음 번에 언급할 지도 모르지만, 하나의 이미지 파일에는 여러 이미지들을 포함하고 있을 수 있습니다.

예를 들면 GIF 애니메이션 이미지 같은 것들이다.

이런 경우에 유용하게 캐시하려면, 다른 옵션을 주어야 할 것입니다.

 

마지막 인자는 생성된 디코더를 저장할 디코더의 포인터입니다.

여기까지 작업하면, 우린 이제 파일을 읽은 디코더를 소유하게 되는 것입니다.

뭔가 절차 상으로 굉장히 복잡한 것처럼 느껴지죠?

 

 

다음으로 할 작업은 프레임(frame) 작업입니다.

프레임이라는 것은 실제 픽셀 데이터를 가지고 있는 비트맵입니다.

앞서 잠깐 언급했듯이, 하나의 이미지 파일은 여러 장의 이미지가 존재할 수 있습니다.

그런 경우를 대비해서 체크를 해야겠지만,

우린 여기서 단 하나의 프레임만이 존재한다고 가정할 것입니다.

디코더의 멤버 함수인 GetFrame()를 통해서 우린 가장 첫 번째 프레임을 얻을 수 있습니다.

이 프레임을 얻는다는 것은 우리가 화면에 표현할 수 있는 이미지를 얻었다는 것입니다.

 

이제 우리는 디코더를 통해서 이미지를 Direct2D에서 표현할 수 있도록

적절하게 변환을 해주어야
합니다.

CreateFormatConverter() API는 이를 위해서 컨버터를 만들어줍니다.

그리고 이 컨버터를 우리가 원하는 형태로 초기화를 시켜 줍니다.

컨버터의 멤버함수 Initialize() 는 이미지를 컨버팅 하면서

픽셀 정보를 보정해 줄 수 있는 많은 옵션을 가지고 있습니다.

이들 옵션에 대한 세부 설정을 하지 않았습니다.

그래서 위에 인자들 형태로 주면, 별다른 이미지의 수정 없이 32비트 포맷으로 남게 됩니다.

 

이제 마지막으로 실제 렌더링 가능한 형태의 메모리를 생성해야 합니다.

렌더타겟의 멤버함수인 CreateBitmapFromWicBitmap() API를 통해서 이 작업을 하게 됩니다.

여기까지 하면, 이미지를 렌더링 하기 위한 준비작업이 모두 끝난 것입니다.

 

저는 여기에 모든 옵션들을 나열하지 않습니다.

( 기본 목적인 이미지를 띄우는데 충실하고자 합니다.^^ )

 

 

생소한 API들이 눈에 많이 띄지만, 이들은 일련의 절차에 지나지 않습니다.

중요한 개념은 이미지를 읽어 들일 디코더를 만들고,

이 이미지 데이터를 Direct2D가 표현할 수 있는 픽셀 데이터로 변환하는 것입니다.

그리고 이 데이터를 렌더타겟에서 표현할 수 있는 비트맵으로 만들어서

렌더링 가능한 상태로 만듭니다.

위의 코드는 바로 이 개념들을 표현하고 있는 것입니다.

 

그러면 실제 WM_PAINT 메시지를 통해서 이들이 어떻게 화면에 그려야 하는지 살펴보겠습니다.

 

WM_PAINT 메시지에서는 렌더타겟이 존재하지 않는 경우, 렌더타겟을 생성합니다.

렌더 타겟이 존재한다면, 비트맵을 그리고 있습니다.

렌더타겟의 렌더링 작업도 BeginDraw() / EndDraw() 의 매커니즘 내부에서

특정 상태를 기반으로 작업을 수행하게 됩니다.

우리는 Clear() 라는 API를 통해서 렌더타겟의 메모리를 흰색으로 채우고 있습니다.

그리고 현재 우리가 이미지를 (0,0) 위치에 (300,300) 크기로 렌더링 합니다.

 

마법의 함수 DrawBitmap()

 

앞선 작업을 통해서 우린 Direct2D를 이용해서 이미지를 화면에 그릴 수 있었습니다.

만약 우리가 읽어 들인 이미지의 일부분만을 화면에 그리고 싶다면 어떻게 해야 할까요?

혹은 흐릿한 효과를 주고 싶다면 어떻게 해야 할까요?

굉장히 어려운 일들 같지만, 이들 기능은 DrawBitmap() 에 모두 옵션 인자로서 존재하고 있습니다.

( 무척 고마운 일이지요..^^ )

그렇기 때문에, 우리는 이 함수를 잘 사용할 수 있어야 합니다.

API의 원형은 다음과 같습니다.

 

<코드>

virtual void DrawBitmap(

[in] ID2D1Bitmap *bitmap,

[in, optional] const D2D1_RECT_F *destinationRectangle = NULL,

         FLOAT opacity = 1.0f,

D2D1_BITMAP_INTERPOLATION_MODE interpolationMode =

D2D1_BITMAP_INTERPOLATION_MODE_LINEAR

,

[in, optional] const D2D1_RECT_F *sourceRectangle = NULL

) = 0;

</코드>

 

첫 번째 인자는 우리가 렌더링 작업을 수행할 이미지입니다.

 

두 번째 인자부터는 옵션적으로 설정할 수 있다.

두 번째 인자는 렌더링 작업을 수행할 화면의 영역을 설정합니다.

NULL 로 설정한다면, 렌더타겟의 원점에 그리게 됩니다.

만약 이미지 크기보다 크게 설정된다면, 자동적으로 이미지를 확대해서 보여주게 됩니다.

 

세 번째 인자는 투명도를 설정합니다.

범위는 0.0~1.0 사이의 값으로 0.0은 투명한 상태를 나타내고 1.0은 불투명한 상태를 나타냅니다.

 

네 번째 인자는 우리가 렌더링하는 이미지가 회전을 하거나 크기가 조정되었을 때,

어떻게 부드럽게 보일 것인가에 대한 옵션을 설정하는 부분입니다.

즉, 보간( interpolation ) 옵션입니다.

 

마지막 인자는 원본 이미지에서 일정 영역을 보여주고 싶을 때 영역을 입력하는 옵션입니다.

이 때 단위는 해당 이미지 파일의 사이즈를 기준으로 영역을 설정해 주면 됩니다.

 

그러면, 간단하게 실제로 이미지의 일부 영역을 약간 투명하게 보여지는 것을 프로그램으로 구현해자면,

앞서 작성했던, 이미지 뷰어의 기능에서 DrawBitmap()만 변경해주면 됩니다.

 

<코드>

HRESULT hr = E_FAIL;

::g_ipRT->BeginDraw();

::g_ipRT->SetTransform( ::D2D1::Matrix3x2F::Identity() );

::g_ipRT->Clear( ::D2D1::ColorF( ::D2D1::ColorF::White ) );

                            

if( ::g_ipD2DBitmap != nullptr )

{

    ::D2D1_RECT_F dxArea = ::D2D1::RectF( 0.0f, 0.0f, 500.0f, 500.0f );

    ::D2D1_RECT_F dxSrc = D2D1::RectF( 0.0f, 0.0f, 250.0f, 250.0f );

    ::g_ipRT->DrawBitmap( ::g_ipD2DBitmap, dxArea, 0.3f,

D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, &dxSrc );

                

}

hr = ::g_ipRT->EndDraw();                

</코드>

 

우리는 간단하게 DrawBitmap() 의 인자들만 변경해주는 것만으로 이미지의 일부 영역만을 보여주고,

투명도를 조절할 수 있음을 확인해 보았습니다.

각각의 값을 변경시키면서, 여러가지 아이디어를 구상해 보기 바랍니다. ^^


아래 소스코드를 첨부합니다..


[STL] 15. VC++ 10에 추가된 새로운 컨테이너 forward_list – 사용편

C++0x 2011. 6. 21. 09:30 Posted by 알 수 없는 사용자

STL의 컨테이너를 사용해보았다면 forward_list라고 해서 딱히 어려운 부분은 없습니다. 다만 forward_list이 단 방향 리스트라는 것과 다른 컨테이너에서는 지원하는 기능이 일부 없다는 것을 잘 숙지해야 합니다.

 

필요한 헤더 파일

forward_list는 이름과 같은 ‘forward_list’라는 헤더 파일을 포함해야 합니다.

#include <forward_list>

 

 

[예제] forward_list를 사용하여 요소 추가, 순회, 삭제하기

#include "stdafx.h"

#include <iostream>

#include <forward_list>

 

using namespace std;

 

 

int main()

{

           forward_list< int > flist;

 

 

           cout << "flist에 추가한 요소들 출력" << endl;

           // 추가하기

           auto iter = flist.before_begin();

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

           {

                     iter = flist.insert_after( iter, i );

           }

                    

           // 순회

           for( iter = flist.begin(); iter != flist.end(); ++iter )

           {

                     cout << *iter << endl;

           }

 

           cout << endl;

           cout << "flist의 요소들 중 일부를 삭제한 후 남은 요소들 출력" << endl;

           // 순회 하면서 일부 요소 삭제

           auto prev_iter = flist.before_begin();

           iter = flist.begin();

           while( iter != flist.end() )

           {

                     if( 3 == *iter )

                     {

                                iter = flist.erase_after( prev_iter );

                                continue;

                     }

                     ++prev_iter;

                     ++iter;

           }

 

           // 순회

           for( iter = flist.begin(); iter != flist.end(); ++iter )

           {

                     cout << *iter << endl;

           }

 

           return 0;

}

 

< 결과 >


 

위 예제를 보면 아시겠지만 forward_list std::list에 비해 성능 면의 이점을 가지고 있지만 사용 측면에서는 조금 불편한 점이 좀 있습니다. 그러나 C와 비슷한 성능을 내고 싶은 경우에는 좋은 선택 기가 될 수도 있습니다.

 


참고

http://msdn.microsoft.com/ko-kr/library/ee373568.aspx

[STL] 14. VC++ 10에 추가된 새로운 컨테이너 forward_list – 소개편

C++0x 2011. 6. 14. 09:30 Posted by 알 수 없는 사용자

앞에까지는 STL의 알고리즘에 추가된 것들을 다루었는데 이번에는 컨테이너 하나를 소개하겠습니다. 사실 이 컨테이너는 저도 얼마 전까지만 하더라도 새로 추가 된지 몰랐습니다.^^;

 

새로 추가된 컨테이너의 이름은 forward_list입니다.

이름을 들어보니 대충 어떤 컨테이너인지 감이 오시죠?^^ 네 이 컨테이너는 기존의 list 컨테이너와 비슷한 종류의 컨테이너입니다.

 

 

forward_list를 만든 이유

표준 라이브러리(STL)에는 이미 리스트(std::list) 라이브러리가 있습니다. 이것은 쌍 방향 리스트입니다. list는 사용하기는 편하지만 사용 메모리나 처리 속도에 조금 아쉬운 점이 있습니다. 또 대 부분의 상황에서 쌍 방향 리스트가 필요한 경우보다는 단 방향 리스트만으로 충분한 경우가 자주 있습니다. 이런 이유로 C++0x에서는 단 방향 리스트를 추가하기로 했습니다.

 

 

forward_list의 설계 방침

1. 특별한 이유가 없다면 forward_list는 기존의 list의 설계에 맞춘다.

2. 설계 상의 선택 기가 여러 개인 경우 성능(속도와 사이즈)을 최우선 한다(C의 구조체로 구현하는 경우와 비교하여 Zero Overhead로 한다).

3. std::list insert eraseforward_list에서도 제공할 수 있지만 구현이 복잡해지고 성능 측면에서 좋지 않으므로 제공하지 않는다.

4. 다른 STL의 컨테이너들에 있는 size 함수를 제공하지 않는다. 이유는 요소 수를 보존하는 멤버를가지고 있으면 C언어에서 구현한 것과 비교해서 불필요한 메모리를 사용한다. 만약 이런 멤버를 가지고 있지 않으면서 size 함수를 지원하면 호출할 때마다 모든 요소를 세어야 하므로 계산량이 O(N)이 된다(그런데 유저는 다른 컨테이너와 같이 size의 계산량이 작을 것이라고 생각할 수 있다). 또 이미 unordered와 같은 연상 컨테이너도 기존의 요소를 만족하지 않고 있다.

 

 

STL list 컨테이너와 다른 점

forward_list는 기존의 list와 아래와 같은 점이 다릅니다.

1. forward_list는 단 방향 리스트(singly-linked-list)이다. 각 요소는 그 다음 요소를 가리키는 포인터를 하나만 가지고 있다(list은 양 방향 리스트).

2. (단 방향 리스트이므로) list에 비해서 메모리를 작게 사용한다. 이것은 각 요소의 메모리만이 아닌 컨테이너 그 자체의 사이즈도 작다. int 형에 대해서 list 12바이트라면 forward_list 8바이트이다(64비트에서는 각각 24, 16).

3. list에 비해 삽입/삭제 속도가 더 빠르지만 그 차이는 크지는 않다

4. 한 방향으로만 이동할 수 있다.

5. 삽입과 삭제는 지정한 요소의 다음 요소만 가능하다.

 

 

forward_list의 멤버 리스트

기능

멤버

대입

assign

반복자

befor_begin

 

cbefore_begin

 

begin

 

end

 

cbegin

 

cend

비었는지 조사

empty

현재 크기(size)

지원 안함

사이즈 변경

resize

모두 삭제

clear

선두에 추가

push_front

선두 요소 삭제

pop_front

선두 요소 참조

front

삽입

insert_after

삭제

erase_after

조건 삭제

remove

 

remove_if

중복 요소 삭제

unique

교환

swap

병합

merge

정렬

sort

반전

reverse

 

[STL] 13. <algorithm>에 추가된 새로운 함수들 minmax_element

C++0x 2011. 5. 30. 09:00 Posted by 알 수 없는 사용자

C++03까지의 STL에는 데이터셋에서 가장 작은 요소를 찾을 때는 min_element, 가장 큰 요소를 찾을 때는 max_element를 사용하였습니다.

그런데 만약 최소와 최대를 동시에 찾을 때는 어쩔 수 없이 min_element max_element를 각각 호출해야 하는 불필요한 불편한 점이 있었습니다.

 

C++0x에서는 이런 불편함을 개선하기 위해 한번에 최소와 최고를 찾아주는 minmax_element 알고리즘이 새로 생겼습니다.

 

 

minmax_element

template<class ForwardIterator>

    pair< ForwardIterator, ForwardIterator >

        minmax_element( ForwardIterator _First, ForwardIterator _Last );

template<class ForwardIterator, class BinaryPredicate>

    pair< ForwardIterator, ForwardIterator >

        minmax_element( ForwardIterator _First, ForwardIterator _Last, BinaryPredicate _Comp );

 

minmax_element 알고리즘에는 조건자를 사용하는 버전과 조건자를 사용하지 않은 버전 두 가지가 있습니다. 데이터셋의 자료형이 유저 정의형(class struct를 사용한)이라면 조건자가 있는 버전을 사용합니다.

 

< 예제 코드 >

#include <iostream>

#include <algorithm>

using namespace std;

 

 

int main()

{

           int Numbers[10] = { 50, 25, 20, 7, 15, 7, 10, 2, 1, 3 };

          

           pair<int*, int*> MinMaxValue = minmax_element( &Numbers[0], &Numbers[10] );

 

           cout << "최소 값 : " << *MinMaxValue.first << endl;

           cout << "최대 값 : " << *MinMaxValue.second << endl;

          

           return 0;

}

 

< 결과 >


 

[STL] 12. <algorithm>에 추가된 새로운 함수들 iota

C++0x 2011. 5. 19. 09:00 Posted by 알 수 없는 사용자

데이터셋을 시퀸스(연속적인)한 값으로 채우고 싶을 때는 iota 알고리즘을 사용합니다.

앞서 소개한 알고리즘들은 <algorithm> 헤더 파일에 정의 되어 있는 것에 반해 iota 알고리즘은 <numeric> 헤더 파일에 정의 되어 있습니다.

 

itoa

template<class ForwardIterator, class T>

  void iota(ForwardIterator first, ForwardIterator last, T value);

 

 

아래는 예제 코드와 결과 입니다.

#include <iostream>

#include <vector>

#include <numeric>

using namespace std;

 

int main()

{

           vector<int> Numberlist;

           Numberlist.push_back( 2 );

           Numberlist.push_back( 5 );

           Numberlist.push_back( 7 );

           iota( Numberlist.begin(), Numberlist.end(), 2 );

 

           for( auto IterPos = Numberlist.begin(); IterPos != Numberlist.end(); ++IterPos )

           {

                     cout << *IterPos << endl;

           }

 

           return 0;

}

 

< 결과 >

 

위 예제를 보면 아시겠지만 iota의 세 번째 인자의 값이 시작 값이고, 이후에 값이 하나씩 증가합니다.

 

[STL] 11. <algorithm>에 추가된 새로운 함수들 is_heap, is_heap_until

C++0x 2011. 5. 11. 09:00 Posted by 알 수 없는 사용자

is_heap is_heap_until는 앞서 소개했던 is_sorted, is_sorted_until과 비슷한 알고리즘입니다. 차이가 있다면 is_heap is_heap_until는 정렬이 아닌 Heap을 다룬다는 것만 다릅니다.

 

is_heap은 데이터셋이 Heap으로 되어 있는지 아닌지, is_heap_until는 데이터셋에서 Heap이 아닌 요소의 첫 번째 위치를 반환합니다.

 

is_heap

template<class RandomAccessIterator>

    bool is_heap(

        RandomAccessIterator _First,

        RandomAccessIterator _Last

    );

template<class RandomAccessIterator, class BinaryPredicate>

    bool is_heap(

        RandomAccessIterator _First,

        RandomAccessIterator _Last,

        BinaryPredicate _Comp

    ); 

 

 

is_heap_until

template<class RandomAccessIterator>

    bool is_heap_until(

        RandomAccessIterator _First,

        RandomAccessIterator _Last

);

template<class RandomAccessIterator, class BinaryPredicate>

    bool is_heap_until(

        RandomAccessIterator _First,

        RandomAccessIterator _Last,

        BinaryPredicate _Comp

);

 

 

is_heap is_heap_until는 각각 조건자를 사용하는 버전과 사용하지 않는 버전 두 개가 있습니다. 조건자를 사용하지 않는 경우는 operator< 를 사용합니다.

 

 

그럼 is_heap is_heap_until을 사용한 아주 간단한 예제 코드를 봐 주세요^^

#include <iostream>

#include <algorithm>

using namespace std;

 

 

int main()

{

           int Numbers1[10] = { 50, 25, 20, 7, 15, 7, 10, 2, 1, 3 };

           int Numbers2[10] = { 50, 25, 20, 7, 15, 7, 10, 6, 11, 3 };

           int Numbers3[10] = { 50, 25, 20, 7, 15, 16, 12, 3, 6, 11 };

          

          

           bool IsResult = false;

           IsResult = is_heap( &Numbers1[0], &Numbers1[10], [](int x, int y) { return x < y; } );

           cout << "Numbers1 Heap인가 ? " << IsResult << endl;

 

           IsResult = is_heap( &Numbers2[0], &Numbers2[10], [](int x, int y) { return x < y; } );

           cout << "Numbers2 Heap인가 ? " << IsResult << endl;

 

           IsResult = is_heap( &Numbers3[0], &Numbers3[10] );

           cout << "Numbers3 Heap인가 ? " << IsResult << endl;

 

           cout << endl;

           int* NumIter = is_heap_until( &Numbers2[0], &Numbers2[10], [](int x, int y) { return x < y; } );

           cout << "Numbers2에서 Heap되지 않은 첫 번째 위치의 값 : " << *NumIter << endl;

 

           return 0;

}

 

< 결과 >

 

 

 

ps : 자료구조 Heap에 대해서 잘 모르시는 분들은 아래의 글을 참고해 주세요

http://blog.naver.com/ctpoyou/105423523


is_sorted는 데이터셋이(컨테이너나 배열) 정렬되어 있다면 true를 반환하고, 그렇지 않다면 false를 반환 합니다.

is_sorted_until는 데이터셋에서 정렬되어 있지 않는 요소의 첫 번째 위치를 반환합니다.

 

is_sortedis_sorted_until의 원형은 아래와 같습니다.

is_sorted

template<class ForwardIterator>

    bool is_sorted( ForwardIterator _First, ForwardIterator _Last );


template<class ForwardIterator, class BinaryPredicate>

    bool is_sorted( ForwardIterator _First, ForwardIterator _Last, BinaryPredicate _Comp );

 

 

is_sorted_until

template<class ForwardIterator>

    ForwardIterator is_sorted_until( ForwardIterator _First, ForwardIterator _Last);

 

template<class ForwardIterator, class BinaryPredicate>

    ForwardIterator is_sorted_until( ForwardIterator _First, ForwardIterator _Last,

               BinaryPredicate _Comp );

 

위의 is_sortedis_sorted_until의 원형을 보시면 알겠지만 조건자(함수객체)를 사용하는 버전과 사용하지 않는 버전 두 가지가 있습니다.

조건자를 사용하지 않는 경우 기본으로 operator<가 적용됩니다.

 

프로그래머는 코드로 이해하죠? ^^ 그럼 바로 예제 코드 들어갑니다.

이번 예제는 간단하게 만들기 위해 정수 배열을 사용해 보았습니다. 아마 STL을 이제 막 공부하고 있는 분들은 알고리즘을 STL의 컨테이너에만 사용할 수 있는 것으로 알고 있는 분들도 있을텐데 그렇지 않습니다. 아래 예제는 int 형 배열을 사용하였습니다.

 

< 예제 코드 >

#include <iostream>

#include <algorithm>

using namespace std;

 

 

int main()

{

           int Numbers1[5] = { 1, 2, 3, 4, 5 };

           int Numbers2[5] = { 5, 4, 3, 2, 1 };

           int Numbers3[5] = { 1, 2, 4, 3, 5 };

           bool IsResult = false;

 

          

           IsResult = is_sorted( &Numbers1[0], &Numbers1[5], [](int x, int y) { return x < y; } );

           cout << "Numbers1. 오름 차순 ? " << IsResult << endl;

 

           IsResult = is_sorted( &Numbers2[0], &Numbers2[5], [](int x, int y) { return x > y; } );

           cout << "Numbers2. 내림 차순 ? " << IsResult << endl;

 

           IsResult = is_sorted( &Numbers3[0], &Numbers3[5], [](int x, int y) { return x < y; } );

           cout << "Numbers3. 오름 차순 ? " << IsResult << endl;

 

           cout << endl;

           cout << "is_sorted에서 조건자(함수객체)를 생략한 경우 " << IsResult << endl;

           IsResult = is_sorted( &Numbers1[0], &Numbers1[5] );

           cout << "Numbers1 is_sorted의 결과는 ? " << IsResult << endl;

           IsResult = is_sorted( &Numbers2[0], &Numbers2[5] );

           cout << "Numbers2 is_sorted의 결과는 ? " << IsResult << endl;

 

           cout << endl;

           int Numbers4[8] = { 1, 2, 3, 5, 4, 5, 7, 8 };

           int* NumIter = is_sorted_until( &Numbers4[0], &Numbers4[5], [](int x, int y) { return x < y; } );

           cout << "Numbers4에서 정렬되지 않은 첫 번째 위치의 값 : " << *NumIter << endl;

 

           return 0;

}

 

< 결과 >


 

 

이번에 설명할 is_partitioned, partition_point는 그 이름처럼 앞서 소개한 partition_copy와 관계가 있는 알고리즘 입니다.

 

is_partitioned의 원형

template<class InputIterator, class BinaryPredicate>

    bool is_partitioned(

        InputIterator _First,

        InputIterator _Last,

        BinaryPredicate _Comp

    );

 

partition_point의 원형

template<class ForwardIterator, class Predicate>

    ForwardIterator partition_point(

        ForwardIterator _First,

        ForwardIterator _Last,

        Predicate _Comp

    );

 

is_partitioned는 데이터셋의 요소가 전반 부와 후반 부 두 개로 나누어져 있는지 조사할 때 사용하고, partition_point는 두 개로 나누어져 있는 데이터셋에서 후반 부의 첫 번째 요소를 가리키는 반복자를 반환합니다.

 

약간 설명이 애매하죠?^^;

예를 들어 설명하면 온라인 FPS 게임에서 8명이 각각 4명씩 레드 팀과 블루 팀으로 나누어서 게임을 하는 경우 vector로 된 StagePlayers(온라인 게임에서 방에 들어온 유저들을 저장)에 앞 부분에는 레드 팀 플레이어 4명을 차례로 저장하고, 그 이후에 블루 팀 플레이어를 저장하고 있는지 조사하고 싶을 때 is_partitioned 알고리즘을 사용하면 알 수 있습니다(맞다면 true를 반환합니다). 그리고 StagePlayers에서 블루 팀의 첫 번째 플레이어에 접근하고 싶다면 partition_point를 사용합니다.  


나름 쉽게 설명한다고 했는데 이해 가시나요? 만약 이해가 안 간다면 예제 코드를 봐 주세요^^

 

< 예제 >

#include <iostream>

#include <algorithm>

#include <vector>

#include <list>

using namespace std;

 

struct PLAYER

{

           int CharCD;

           bool IsRedTeam;

};

 

 

int main()

{

           vector< PLAYER > StagePlayers1;

           PLAYER player1; player1.CharCD = 1;         player1.IsRedTeam = true;           StagePlayers1.push_back( player1 );

           PLAYER player2; player2.CharCD = 2;         player2.IsRedTeam = true;           StagePlayers1.push_back( player2 );

           PLAYER player3; player3.CharCD = 3;         player3.IsRedTeam = true;           StagePlayers1.push_back( player3 );

           PLAYER player4; player4.CharCD = 4;         player4.IsRedTeam = false;                      StagePlayers1.push_back( player4 );

           PLAYER player5; player5.CharCD = 5;         player5.IsRedTeam = false;                      StagePlayers1.push_back( player5 );

           PLAYER player6; player6.CharCD = 6;         player6.IsRedTeam = false;                      StagePlayers1.push_back( player6 );

           PLAYER player7; player7.CharCD = 7;         player7.IsRedTeam = false;                      StagePlayers1.push_back( player7 );

 

           bool IsPartitioned = is_partitioned( StagePlayers1.begin(), StagePlayers1.end(),

                                                                                     []( PLAYER player ) -> bool { return player.IsRedTeam; } );

           if( IsPartitioned ) {

                     cout << "레드 팀과 블루 팀으로 구분 되어 나누어져 있습니다." << endl;

           } else {

                     cout << "레드 팀과 블루 팀으로 구분 되어 있지 않습니다." << endl;

           }

 

           vector< PLAYER >::iterator IterFirstBlueTeamPlayer = partition_point( StagePlayers1.begin(),StagePlayers1.end(),

                                                     []( PLAYER player ) -> bool { return player.IsRedTeam; } );

           if( IterFirstBlueTeamPlayer != StagePlayers1.end() ) {

                     cout << "첫 번째 블루 팀 플레이어. 캐릭터 코드 : " << (*IterFirstBlueTeamPlayer).CharCD << endl;

           }

 

                    

           vector< PLAYER > StagePlayers2;

           StagePlayers2.push_back( player7 );

           StagePlayers2.push_back( player6 );

           StagePlayers2.push_back( player1 );

           StagePlayers2.push_back( player5 );

           StagePlayers2.push_back( player4 );

           StagePlayers2.push_back( player3 );

           StagePlayers2.push_back( player2 );

          

           IsPartitioned = is_partitioned( StagePlayers2.begin(), StagePlayers2.end(),

                                                                                     []( PLAYER player ) -> bool { return player.IsRedTeam; } );

           if( IsPartitioned ) {

                     cout << "레드 팀과 블루 팀으로 구분 되어 나누어져 있습니다." << endl;

           } else {

                     cout << "레드 팀과 블루 팀으로 구분 되어 있지 않습니다." << endl;

           }

 

           getchar();

           return 0;

}

 

< 결과 >

 

예제 코드를 보니 쉽게 이해 되시죠? 그럼 저는 아는 걸로 생각하고 다음 포스팀에서는 다른 알고리즘을 설명하겠습니다^^

 

 

[STL] 8. <algorithm>에 추가된 새로운 함수들 - partition_copy

C++0x 2011. 4. 12. 09:00 Posted by 알 수 없는 사용자

partition_copy 알고리즘은 하나의 집단에서 서로 다른 두 개의 집단으로 나눌 때 사용하는 것이라고 아주 간단하게 말할 수 있습니다.

 

partition_copy

template<class InputIterator, class OutputIterator1, class OutputIterator2, class Predicate>

    pair<OutputIterator1, OutputIterator2>

        partition_copy(

            InputIterator _First,

            InputIterator _Last,

            OutputIterator1 _Dest1,

            OutputIterator2 _Dest2,

            Predicate _Pred

        );

 데이터셋의 _First _Last 사이에 있는 각 요소 x를 조건자 _Pred에 인자를 넘겼을 때 true를 반환하면 x _Dest1, false를 반환하면 _Dest2에 복사하고 지정된 구간의 모든 요소를 다 처리하면 OutputIterator 값을 pair로 반환한다

 

그럼 좀 더 쉽게 이 알고리즘을 어떤 경우에 사용하는지 알 수 있도록 간단한 예제를 하나 보여드리겠습니다.

 ) 게임 아이템들을 팔 수 있는 것과 팔 수 없는 것으로 나누어라

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
using namespace std;

struct ITEM
{
    int nItemCode;
    bool bEnableSell;
};

int main()
{
    vector< ITEM > AllItems;
    ITEM item1; item1.nItemCode = 1;    item1.bEnableSell = false;        AllItems.push_back( item1 );
    ITEM item2; item2.nItemCode = 2;    item2.bEnableSell = true;        AllItems.push_back( item2 );
    ITEM item3; item3.nItemCode = 3;    item3.bEnableSell = true;        AllItems.push_back( item3 );
    ITEM item4; item4.nItemCode = 4;    item4.bEnableSell = false;        AllItems.push_back( item4 );
    ITEM item5; item5.nItemCode = 5;    item5.bEnableSell = true;        AllItems.push_back( item5 );
    ITEM item6; item6.nItemCode = 6;    item6.bEnableSell = false;        AllItems.push_back( item6 );
    ITEM item7; item7.nItemCode = 7;    item7.bEnableSell = true;        AllItems.push_back( item7 );

    ITEM UnItem; UnItem.nItemCode = 0;
    list< ITEM > SellItems( 7, UnItem );            
    list< ITEM > UnSellItems( 7, UnItem );
    
    pair<list< ITEM >::iterator, list< ITEM >::iterator > SeperateItems;
    SeperateItems = partition_copy( AllItems.begin(), AllItems.end(),
                                                 SellItems.begin(),
                                                 UnSellItems.begin(),
                                                   []( ITEM& item ) { return item.bEnableSell; } );

    cout << "팔 수 있는 아이템" << endl;
    for each( ITEM item in SellItems )
    {
        if( item.nItemCode <= 0 ) {
            continue;
        }
        cout << "아이템 코드 : " << item.nItemCode << endl;
    }

    cout << endl << endl;

    cout << "팔 수 없는 아이템" << endl;
    for( auto Iter = UnSellItems.begin(); Iter != UnSellItems.end(); ++Iter )
    {
        if( Iter->nItemCode <= 0 ) {
            continue;
        }
        cout << "아이템 코드 : " << Iter->nItemCode << endl;
    }
    
    getchar();
    return 0;
}

< 결과 >


partition_copy를 사용할 때 한 가지 주의할 점은 결과를 다른 컨테이너에 복사를 하므로 해당 컨테이너에 공간이

확보되어 있어 있어야 합니다. 그래서 위의 예제에도

ITEM UnItem; UnItem.nItemCode = 0;
list< ITEM > SellItems( 7, UnItem );            
list< ITEM > UnSellItems( 7, UnItem );

로 더미 값을 넣어서 복사할 공간을 확보하고 있습니다.

 

참조 : http://msdn.microsoft.com/ko-kr/library/ee384416.aspx

 

[SafeInt] C++에서 안전한 정수 연산을 하자 - 4

Visual C++ 10 2011. 3. 7. 09:00 Posted by 알 수 없는 사용자

이번이 SafeInt 라이브러리에 대한 4번째 글이면서 마지막 글입니다. 이전 회의 제 글을 보셨다면 SafeInt가 어떤 것인지, 어떻게 사용하는지 대부분 알게 되셨습니다. 이번에는 SafeInt의 함수 버전에 대해서 설명합니다.

 

 

SafeInt 함수

SafeInt 라이브러리에는 SafeInt 클래스의 인스턴스를 만들지 않고 사용할 수 있도록 몇 개의 함수를 지원하고 있습니다. SafeInt 함수는 정수 오버플로우가 발생하지 않도록 단일 수치 연산을 보호하고 싶을 때 사용합니다. 그리고 복수의 수치 연산을 보호하고 싶을 때는 SafeInt 클래스를 사용하고 함수 버전들을 반복하여 사용하는 것보다는 SafeInt 클래스를 사용하는 것이 더 효율적이라고 합니다.

 

함수

설명

SafeAdd

두 개의 값을 더한다

SafeCast

다른 형으로 캐스팅한다

SafeDivide

두 개의 값으로 나눈다

SafeEquals, SafeGreaterThan, SafeGreaterThanEquals, SafeLessThan, SafeLessThanEquals, SafeNotEquals

2개의 값을 비교한다. 이 함수들을 사용하면 서로 형이 다른 두 개의 값을 형 변환하지 않고 비교할 수 있다

SafeModulus

나머지를 구한다

SafeMultiply

두 개의 값을 곱한다

SafeSubtract

두 개의 값을 뺀다.

 

 

함수들의 이름만 봐도 어떤 것인지 알 수 있고, 이미 어떤 역할을 하는지 아실 테니 따로 길게 설명은 하지 않겠습니다. 아주 간단한 예제를 보여드릴 테니 그것을 보고 대충 어떻게 사용하는지 이해하고 부족한 부분은 MSDN을 참고해 주세요

 

#include <iostream>

#include <safeint.h>

using namespace msl::utilities;

 

 

int main()

{

           unsigned char X1 = 123;

           unsigned char X2 = 200;

           unsigned char X3 = 0;

           if( false == SafeAdd( X1, X2, X3 ) ) {

                     std::cout << "Overflow 발생!!" << std::endl;

           }

          

           unsigned int AA = 100;

           short BB = 101;

           if( false == SafeEquals( AA, BB ) ) {

                     std::cout << "AA BB는 서로 다릅니다" << std::endl;

           }

 

           getchar();

           return 0;

}

< 결과 >


 

 


참고

SafeInt 함수

http://msdn.microsoft.com/ko-kr/library/dd575188.aspx

 

[SafeInt] C++에서 안전한 정수 연산을 하자 - 3

Visual C++ 10 2011. 3. 2. 09:00 Posted by 알 수 없는 사용자

SafeInt의 예외처리 두 번째 방법은 기본 예외처리 정책을 컴파일 타임에서 선언하는 것입니다.

앞 글에서 우리가 만든 예외처리 클래스를 사용하기 위해 SafeInt를 정의할 때 예외처리 클래스를 템플릿 파라미터의 인자로 넘겼는데 이번에 소개하는 방법은 이 예외처리 클래스 템플릿 인자를 미리 정의해 놓는 것입니다.

 

방법은 SafeInt 헤더파일을 선언하기 전에 #define 문으로 _SAFEINT_DEFAULT_ERROR_POLICY에 예외처리에 사용할 클래스를 선언합니다.

 

// MySafeIntException 이 우리가 정의한 예외처리 클래스입니다.

#define _SAFEINT_DEFAULT_ERROR_POLICY MySafeIntException

 

#include <safeint.h>

 

이렇게 #define 문으로 SafeInt에서 사용할 예외처리 클래스를 선언하고 예외처리 클래스를 정의하면 SafeInt를 선언할 때 템플릿 파라미터로 형만 선언하면 이후 SafeInt를 사용하다가 예외가 발생하면 #define에서 선언한 예외처리 클래스를 호출합니다.

 

#include <iostream>

#define _SAFEINT_DEFAULT_ERROR_POLICY MySafeIntException

 

#include <safeint.h>

using namespace msl::utilities;

 

 

class MySafeIntException : public SafeIntException

{

public:

           static void SafeIntOnOverflow()

           {

                     std::cout << "Overflow 발생!!" << std::endl;

           }

 

           static void SafeIntOnDivZero()

           {

                     std::cout << "0으로 나누기 발생!!" << std::endl;

           }

};

 

 

int main()

{

           SafeInt<unsigned int> X1(1234567);

           SafeInt<unsigned int> X2(1234567);

          

           SafeInt<unsigned int> X3 = X1 * X2;

          

           getchar();

           return 0;

}

 

이전 회에서 소개한 방법과 별 차이 없이 #define 문을 사용한다는 것만 다르니 쉽게 이해했으리라 생각합니다.

 

이제 SafeInt를 사용할 때는 예외처리를 위해 우리는 3가지 방식을 사용할 수 있습니다,

1. try{} catch{}

2. SafeInt에서 사용할 예외처리 클래스를 정의 후 SafeInt 선언 시에 사용

3. #define 문을 사용하여 SafeInt에서 사용할 기본 예외처리 클래스 선언

 

SafeInt 라이브러리는 클래스만 있는 것이 아닙니다. 함수로도 지원합니다. SafeInt의 함수 버전은 SafeInt에 대한 마지막 글이 될 다음 포스팅을 통해서 설명하겠습니다.

 

[SafeInt] C++에서 안전한 정수 연산을 하자 - 2

Visual C++ 10 2011. 2. 22. 09:00 Posted by 알 수 없는 사용자

이전 글에서 SafeInt를 사용하여 정수 연상을 할 때 오버플로우가 발생할 때 예외처리를 하지 않으면 릴리즈 모드에서는 크래쉬가 발생한다고 하였습니다. 그래서 SafeInt를 사용할 때 꼭 예외처리를 사용해야 합니다.

 

< 코드 1. SafeInt 연산 시 예외처리 구현 >

#include <iostream>

#include <safeint.h>

 using namespace msl::utilities;

 

int main()

{

           SafeInt<unsigned int> X1(1234567);

           SafeInt<unsigned int> X2(1234567);

          

           try

           {

                     SafeInt<unsigned int> X3 = X1 * X2;

           }

           catch(SafeIntException e)

           {

                     std::cout << "overflow!!. ErrorCode : " << e.m_code << std::endl;

           }

 

           getchar();

           return 0;

}

 

< 결과 >

 

 <코드 1>의 결과를 보면 예외 처리에 의해서 프로그램이 크래쉬 되지 않음을 알 수 있습니다. 그런데 SafeInt를 사용할 때마다 <코드1> 처럼 매번 예외처리를 구현한다는 것은 너무 불편합니다. 불편하면 SafeInt를 기피하게 되겠죠. -_-

다행히 SafeInt는 이런 것도 다 감안해서 만들어져 있습니다. 사전에 예외처리를 미리 정의 해 놓으면 매번 예외처리를 정의할 필요가 없습니다.

SafeInt의 예외처리 정의는 두 가지 방법이 있습니다. 이번 회는 두 가지 방법 중 첫 번째 방법을 소개하고 두 번째 것은 다음 회에 소개 하겠습니다.

 

 

 

SafeInt의 예외처리 방법 1

SafeInt의 기본 예외 처리 클래스를 상속 받아서 우리가 원하는 방식으로 정의한 후 그것을 SafeInt의 생성자에 인자로 넘겨주면 SafeInt로 연산 작업을 할 때 예외가 발생하면 우리가 정의한 예외처리를 호출합니다. 백문이불여일견이라고 바로 다음의 코드를 봐 주세요. 아주 간단합니다.

 

< 코드 2. SafeInt의 예외처리 방법 1 >

#include <iostream>
#include <safeint.h>

using namespace msl::utilities;

 

class MySafeIntException : public SafeIntException

{

public:

           static void SafeIntOnOverflow()

           {

                     std::cout << "Overflow 발생!!" << std::endl;

           }

 

           static void SafeIntOnDivZero()

           {

                     std::cout << "0으로 나누기 발생!!" << std::endl;

           }

};

 

int main()

{

           SafeInt<unsigned int, MySafeIntException> X1(1234567);

           SafeInt<unsigned int, MySafeIntException> X2(1234567);

          

           SafeInt<unsigned int, MySafeIntException> X3 = X1 * X2;

          

           getchar();

           return 0;

}

 

< 결과 >

 

 <코드 2>의 결과를 보면 SafeInt로 연산 작업을 할 때 예외처리를 같이 정의하지 않아도 오버플로우로가 발생하면 우리가 정의한 클래스의 멤버 함수를 호출 합니다.

 

SafeInt의 생성자에 인자로 넘기는 예외처리 클래스는 꼭 SafeIntException 클래스를 상속 받고 static void SafeIntOnOverflow()static void SafeIntOnDivZero()를 재정의해야 합니다.

 

이것으로 <코드 1>의 예외처리 방식보다는 좀 편리해졌습니다. 그런데 아마 지금도 마음에 들지 않는 분이 있을 것 같습니다. SafeInt를 생성 할 때마다 매번 예외처리 클래스를 인자로 넘기는 것도 귀찮은 분이 있을 것 같네요. 이런 분들을 위해서 SafeInt는 또 하나더 예외처리 방법을 지원합니다. 그것은 다음 회에서 설명하겠습니다.^^

[SafeInt] C++에서 안전한 정수 연산을 하자 - 1

Visual C++ 10 2011. 2. 14. 09:00 Posted by 알 수 없는 사용자
#include <iostream> 

int main()

{

           unsigned int X1 = 1234567;

           unsigned int X2 = 1234567;

           unsigned int X3 = X1 * X2;

           std::cout << "X3 = " << X3 << std::endl;

 

           unsigned __int64 BigX1 = 1234567;

           unsigned __int64 BigX2 = 1234567;

           unsigned __int64 BigX3 = BigX1 * BigX2;

           std::cout << "BigX3 = " << BigX3 << std::endl;

 

           getchar();

           return 0;

}

 

<코드1>를 실행하면 변수 X3 BigX3의 값이 서로 같을까요? 혹시 같다고 생각하시는 분들은 unsigned int의 최대 값이 얼마인지 MSDN에서 검색해 보세요... 네 결과는 서로 다릅니다. 둘 다 계산에 사용하는 값은 같지만 결과가 다르게 나오는 이유는 unsigned int로는 X1 X2를 곱해서 나온 값을 보관할 수 없기 때문입니다. X3 = X1 * X2에서 X3는 오버플로우가 발생하여 상위 비트가 삭제되어 올바른 계산 값이 저장되지 않습니다.

 

<코드 1의 결과>


 

<코드 1>의 코드는 사실 별로 길지 않은 코드이기 때문에 실행하기 전에 오버플로우가 발생하리라는 것을 충분히 예상할 수 있고, 혹은 실행 후에 X3의 값이 예상하지 못한 값이 들어가 있어도 문제를 쉽게 파악할 수 있을 것입니다. 그러나 우리가 만드는 애플리케이션은 복잡하고 긴 코드를 가지고 있습니다. <코드 1>과 같은 오버플로우에 의해서 버그가 발생하면 쉽게 버그를 찾기 힘들고 특히 오버플로우에 의해 애플리케이션이 오 동작하여 크래쉬가 발생할 수도 있습니다.

 

안전한 애플리케이션을 만들기 위해서는 안전한 코드를 만들어야 합니다. 보통 안전한 코드를 생각하면 포인터 조작과 문자열 조작을 주로 중요하게 다루고 VC++에서도 안전한 문자열 조작 위해 ‘_s’가 붙은 문자열 조작함수를 사용하도록 VC++에서 종용하고 있어서 요즘은 대 부분 이것을 사용하고 있습니다. 그러나 정수 계산에 대해서는 안전한 코드를 위해 지원해 주는 것이 없었습니다.

 


SafeInt 란?

VC++ 10에서는 안전한 정수 계산을 위해서 새로운 라이브러리를 지원해 줍니다. 이 라이브러리의 이름은 SafeInt 입니다. SafeIntC++의 템플릿으로 만들어서 char 형에서 __int64 형까지 8비트에서 64비트 사이의 크기를 가진 모든 정수 형을 사용할 수 있습니다.

SafeInt 라이브러리를 사용하면 결과를 담을 변수의 형 보다 큰 정수 값 연산을 하거나 0으로 나누기 연산을 할 때 발생하는 오버플로우를 감지 할 수 있습니다.


 

SafeInt 사용

SafeInt를 사용하기 위해서는 헤더 파일 safeint.h 를 포함하고 msl::utilities 이름 공간을 선언해야 합니다.


 < 코드 2 >

#include <iostream>

#include <safeint.h>

using namespace msl::utilities;

 

int main()

{

           SafeInt<unsigned int> X1(1234567);

          

           unsigned int x2 = 1234567;

           SafeInt<unsigned int> X2(x2);


           SafeInt<unsigned int> X3 = X1 * X2;     

        

           getchar();

           return 0;

}

 

<코드 2>를 디버그 모드에서 실행하면 아래와 같은 ASSERT 메시지가 발생합니다.


 

이유는 오버플로우가 발생했기 때문입니다. 그러나 릴리즈 모드에서는 ASSERT 메시지가 발생하지 않습니다. 다만 크래쉬가 발생합니다. -_-;;

오버플로우에 의해서 디버그 모드에서는 ASSERT 메시지, 릴리즈 모드에서는 크래쉬가 발생하는 이유는

SafeInt<unsigned int> X3 = X1 * X2;

에서 예외가 발생하기 됩니다. SafeInt를 사용하는 경우 오버플로우가 발생하면 예외를 발생시키기 때문에 try{} catch{}로 예외를 처리해 주지 않으면 안됩니다. 예외 처리가 올바르게 하면 오버플로우가 발생했을 때 발생하는 문제를 올바르게 대처하던가 어디에서 어떻게 오버플로우가 발생했는지 쉽게 알 수 있습니다.

 

그리고 SafeInt는 일반 정수형과 같이 연산을 할 수도 있다.

<코드 3>

#include <iostream>

#include <safeint.h>

 

using namespace msl::utilities;

 

int main()

{

           SafeInt<unsigned int> X1(1234567);

          

           unsigned int X2 = 123;

           SafeInt<unsigned int> X3 = X1 * X2;

          

           getchar();

           return 0;

}


 

이번 회에는 간단하게 정수 연산 시의 오버플로우 문제와 SafeInt가 무엇인지, SafeInt의 간단한 사용 방법만 설명하였습니다.

다음 회는 <코드 2>에서 발생하는 예외를 어떻게 처리하는지 설명하겠습니다.

 

[Step. 25] 닷넷에서 HalfNetwork를 사용하자 – 6(마지막)

C++/CLI 2011. 1. 31. 09:00 Posted by 알 수 없는 사용자

앞서 C++/CLI로 만든 클래스 라이브러리를 사용하여 아주 간단한 콘솔 환경의 서버 프로그램을 만들어 보겠습니다.

 

C#에서 Console 프로젝트를 생성합니다.

생성 후 솔루션 탐색기에서 참조에 클래스 라이브러리를 추가합니다.


 

HalfNetworkNET 클래스를 상속 받는 클래스를 생성합니다. 저는 HFServer라는 클래스를 만들었습니다.

그런 후 상속 받은 HalfNetworkNET 클래스의 일부 함수를 재정의 합니다.


 

이제 Main 부분만 남았습니다.

namespace TestServer_HFNetworkNET

{

    class Program

    {

        static void Main(string[] args)

        {

            HFServer Server = new HFServer();

 

            // 서버 초기화 및 설정 후 Port를 연다

Server.Init();

            short nRet = Server.Open();

 

            if (HalfNetwork_NET.ERRORCODE.NONE != nRet)

            {

                Console.WriteLine("Failed Server Open!");

                return;

            }

 

            Console.WriteLine("Server Start !!!");

 

            // 네트웍 처리를 한다.

            while (true)

            {

                Server.Run();

            }

 

            Console.WriteLine("End Server");

 

            // 서버 종료 처리를 한다

            Server.End();

        }

    }

}

 

 

이것으로 아주 간단한 Echo 서버가 만들어졌습니다.

자세한 코드는 첨부된 프로젝트를 보시기 바랍니다.

 

이 프로그램을 실행하면 아래와 같습니다.



프로그램이 올바르게 실행되는지 테스트 하기 위해서는 HalfNetwork 솔루션에 있는 TestClient 프로젝트를 빌드한 후 실행하면 됩니다.

오른쪽이 클라이언트 입니다. 여기서는 10개를 접속 후 0.5초마다 패킷을 보내면 서버(왼쪽)는 받은 데이터를 그대로 보냅니다.


종료하면 종료된 세션을 콘솔에 출력합니다.


닷넷 플랫폼에서 서버 프로그램을 만드는 경우 닷넷 프레임웍에서 제공하는 API를 사용해도 좋지만 기존에 만들어져 편리하고 고성능 라이브러리를 사용하는 것도 아주 괜찮은 선택입니다.

C++로 만들어진 라이브러리를 C++/CLI를 사용하여 필요한 부분만 랩핑하여 클래스를 만들면 닷넷에서 마음껏 사용할 수 있습니다.


 

 

[Step. 24] 닷넷에서 HalfNetwork를 사용하자 – 5

C++/CLI 2011. 1. 24. 09:00 Posted by 알 수 없는 사용자

HalfNetwork_NET.h, HalfNetwork_NET.cpp

 

HalfNetwork ACE를 사용하고 있습니다. 그래서 프로그램이 시작할 때 ACE ACE::Init()를 호출하고, 종료하기 전에는 ACE::fini()를 호출해야 합니다. 이 두 함수는 각각

static void Init_ACE();

static void End_ACE();

에서 호출하고 있습니다.

 

 

네트웍 설정 및 소켓 생성 및 사용은

short Opne();

에서 합니다.

 

내용을 보면 네트웍 설정 정보를 ini 파일을 읽어서 설정합니다.

ini 파일의 내용은 아래와 같습니다.

server_port=15001;

client_port=25251;

workerthread=0;

receivebufferlength=2048;

updateterm=20;

 

server_receive_buff_size=65536;

client_receive_buff_size=4096;

 

client_init_accept_count=126;

 

그리고 이 라이브러리는 서버에서 사용하는 것을 생각했기 때문에 서버-클라이언트 연결과 서버-서버 연결을 가정하여 클라이언트 접속을 위한 Port와 서버 접속을 위한 Port 두 개를 생성합니다.

 

Windows 플랫폼에서는 네트웍 성능을 최대한 내기 위해서는 IOCP를 사용해야 합니다.

HalfNetwork에서 IOCP를 사용하기 위해서는 Proactor 방식을 사용해야 합니다.

if( false == NetworkInstance->Create<HalfNetwork::ProactorFactory>() )

{

          return ERRORCODE::CREATE_PROACTORFACTORY;

}

 

 

설정 작업이 끝나면 Port를 오픈합니다.

if( false == NetworkInstance->Open(&config) ) {

        return ERRORCODE::SERVER_OPEN;

}

 

 

리모트에서 온 데이터를 받기 위해서는

void ProcessRecvQueue();

를 호출합니다.

 

서버가 종료되기 전까지는 ProcessRecvQueue();는 계속 호출해야합니다.

그래서 ProcessRecvQueue() Update()에서 호출하고 있습니다.

 

 

리모트의 접속, 데이터 받기, 연결 끊어짐을 처리하기 위해서는 HalfNetwork_NET 클래스를 상속 받은 클래스가 아래의 함수를 재정의 해야합니다.

virtual void OnAccept_Client( unsigned int StreamID, String^ IP ) abstract;

virtual void OnRead_Client( unsigned int StreamID, array<Byte>^ RecvData ) abstract;

virtual void OnDisConnect_Client( unsigned int StreamID ) abstract;

virtual void OnAccept_Server( unsigned int StreamID, String^ IP ) abstract;

virtual void OnRead_Server( unsigned int StreamID, array<Byte>^ RecvData ) abstract;

virtual void OnDisConnect_Server( unsigned int StreamID ) abstract;

 

이것으로 간단하게 HalfNetwork 라이브러리를 사용하기 위해 닷넷용 클래스 라이브러리를 만드는 것은 끝났습니다.

다음에는 C#으로 이것을 사용하도록 해보겠습니다.

 

 

[Step. 23] 닷넷에서 HalfNetwork를 사용하자 – 4

C++/CLI 2011. 1. 17. 09:00 Posted by 알 수 없는 사용자

C++/CLI용의 클래스 라이브러리 프로젝트를 생성합니다.

저는 HalfNetwork_NET 이라는 이름으로 만들었습니다.

 

프로젝트 설정 하기

앞서 C++에서 만든 HalfNetwork lib 파일을 사용하기 위해 프로젝트 속성에서 몇 가지를 설정합니다.

 

1. HalfNetwork 프로젝트의 헤더 파일을 포함합니다.


 

2. lib 파일의 위치를 설정합니다.


 

이것으로 프로젝트 설정은 끝났습니다.

 

 

코딩 하기

HalfNetwork_NET 프로젝트는 아주 간단하게 만들 생각이므로(만약 실전에서 사용한다면 사용할 프로젝트에 맞게 필요한 기능을 만들어야겠죠) 저는 총 6개의 파일만 사용합니다.

자세한 내용은 첨부되는 코드를 직접 보시기 바라며 여기서는 간단한 설명만 하겠습니다.

 

Stdafx.h

ErrorCode.h

ServerNetwork.h

ServerNetwork.cpp

HalfNetwork_NET.h

HalfNetwork_NET.cpp

 

 

Stdafx.h

여기에서는 HalfNetwork를 사용하기 위해 필요한 파일을 포함합니다.

#include <stdio.h>

#include <string>

#include <vector>

 

#include <ace/Singleton.h>

#include <ace/ace.h>

#include "HalfNetworkType.h"

#include "HalfNetworkDefine.h"

 

 

ErrorCode.h

에러 코드 값을 선언한 파일입니다.

참고로 enum을 사용하지 않고 literal을 사용했는데 이유는 enum을 정의할 때 타입을 지정했는데도 사용할 때 타입캐스팅을 요구해서(왜 그런지 잘 모르겠네요) 사용하기 편하기 위해서 C++에서 const와 같은 역할을 할 literal을 사용했습니다.


 

ServerNetwork.h, ServerNetwork.cpp

아주 단순하게 네트웍으로 리모트에 Send하는 기능만 가지고 있습니다.

HalfNetwork Send를 사용하기 위해서는 네트웍으로 보낼 데이터를 ACE_Message_Block 객체를 만든 후 복사합니다.

bool ServerNetwork::Send( const DWORD StreamID, array<Byte>^ SendData )

{

           int nLength = SendData->Length;

           pin_ptr<Byte> pData = &SendData[0];

                    

           ACE_Message_Block* block = NetworkInstance->AllocateBlock( nLength );

           block->copy( (const char*)pData, nLength );

           NetworkInstance->SendRequest( StreamID, block );

 

           pData = nullptr;

           return true;

}

 파라미터 중 StreamID는 연결된 세션의 인덱스이고 SendData는 보낼 데이터입니다.

 

 

이번 회는 여기까지 하고 나머지는 다음 회에 이어서 설명하겠습니다.

 

 

[Step. 21] 닷넷에서 HalfNetwork를 사용하자 - 2

C++/CLI 2010. 12. 30. 09:00 Posted by 알 수 없는 사용자

HalfNetwork 소개

HalfNetwork는 온라인 게임서버 프로그래머인 javawork( http://javawork.egloos.com/ )이 만든 것으로 기반은 유명한 네트웍 프레임웍인 ACE( http://www.cs.wustl.edu/~schmidt/ACE.html )를 사용 하였습니다.

 

ACE는 정말 좋은 네트웍 프레임웍이지만 너무 범용적이라서 고도로 추상화 되었고, 기능이 다양하여 분석하기가 쉽지 않아서 사용에 어려움이 있습니다.

HalfNetwork javawork님이 다년간 온라인 게임 서버를 만든 경험을 바탕으로 서버 프로그램을 만들 때 필수적이고 자주 사용하는 기능을 쉽게 사용할 수 있도록 만든 것으로 서버와 클라이언트 용 둘 다 지원합니다. 그래서 ACE의 장점이 높은 성능과 다양한 기능, 멀티 플랫폼 지원을 이어 받으면서 아주 쉽게 서버 프로그램을 만들 수 있습니다( ACE를 몰라도 괜찮습니다).

 

 

HalfNetwork에 대한 소개

http://javawork.egloos.com/2174089

 

HalfNetwork 프로젝트 사이트

http://code.google.com/p/halfnetwork/

 

HalfNetwork에 대한 문서

http://code.google.com/p/halfnetwork/w/list

http://jacking.tistory.com/category/HalfNetwork


HalfNetwork에 대한 질문은 구글그룹스에

http://groups.google.com/group/halfnetwork?hl=ko



HalfNetwork는 현업에서 개발하고 있는 MMORPOG 게임, 온라인 캐주얼 게임이나 일반 비즈니스 프로그램에서 사용되고 있습니다.

현재 HalfNetwork Visual C++ 89 그리고 최신인 10까지 지원하고 있습니다. 또한 64비트 개발에도 문제가 없습니다.

HalfNetwork 프로젝트에는 네트웍 라이브러리 뿐만이 아닌 데이터베이스 프로그래밍에서 사용할 ADO 라이브러리와 Json을 패킷 프로토콜로 사용할 수 있도록 JsonPacket라는 라이브러리도 있습니다.

 

그럼 HalfNetwork에 대한 소개는 마치고 다음 회부터는 드디어 본격적으로 프로그래밍에 들어가겠습니다^^

 

[Step. 20] 닷넷에서 HalfNetwork를 사용하자 - 1

C++/CLI 2010. 12. 27. 09:00 Posted by 알 수 없는 사용자

C++/CLI를 가장 자주 사용하는 경우가 아마 C++로 만든 코드를 닷넷에서 사용하고 싶을 때라고 생각합니다. 게임 개발에서는 보통 3D 툴을 만들 때 C++/CLI를 유용하게 사용합니다.

 

C++/CLI를 툴 개발에서 사용할 때는 보통 두 가지로 사용하는데 첫 번째는 C++로 만든 3D 엔진 코어를 DLL로 만들어서 C#을 이용하여 툴을 만들던가, 두 번째는 C++/CLI에서 관리코드와 비관리코드를 같이 사용할 때입니다.

 

제가 앞서 C++/CLI에 대해서 설명한 것들은 C++/CLI로만 프로그래밍 하는 것보다는 관리코드와 비관리코드를 같이 사용할 때를 생각하여 이때 필요로 하는 부분을 중심으로 했습니다. 그래서 아직 C++/CLI에 대한 많은 부분들이 빠져있습니다. 빠진 부분에 관심이 있는 분들은 C++/CLI 책이나 MSDN을 통해서 공부하시기 바랍니다.

 

앞으로 C++로 만든 코드를 C++/CLI를 사용하여 닷넷용 클래스 라이브러리를 만든 후 이것을 C#에서 사용하여 프로그램을 만든다는 경우로 간단한 프로그램을 만들면서 C++/CLI을 어떻게 사용하는지 몇 회에 걸쳐서 설명하겠습니다.

 

만들 프로그램은 네트웍 서버 애플리케이션입니다(제가 회사에서 맡은 직무가 온라인 게임 서버 개발입니다). ^^

 

 

네트웍 라이브러리(또는 프레임웍)

네트웍 프로그래밍은 일반적인 프로그래밍은 아니고 시스템 프로그래밍입니다. 조금은 특수한 분야라고 할 수 있습니다.

그러나 한국의 게임업계는 거의 대부분이 온라인 게임이라서 네트웍 프로그래밍이라는 것이 특수한 부분은 아닙니다.

 

보통 게임 프로그래밍이라는 것은 그래픽스 프로그래밍을 쉽게 떠올리고, 시중에 관련 책이나 학원들이 있습니다. 그러나 네트웍 프로그래밍에 관한 책이나 학원은 별로 없습니다(특히 전문 학원은 없는 것으로 알고 있습니다).

온라인 게임에서의 네트웍 프로그래밍을 한다라는 것은 대용량 네트웍 프로그램을 만들어야 한다는 것입니다. 그래서 온라인 게임 서버 프로그램을 만들려면 시스템 프로그래밍에 관한 지식과 네트웍 프로그래밍에 대한 경험이 필요합니다.

이런 이유 때문에 서버 프로그램을 만든다는 것은 쉽지 않습니다. 그러나 서버 프로그램을 쉽게 만들 수 있도록 도와주는 라이브러리를 사용할 수 있다면 어려움은 한층 작아질 것입니다.

 


온라인 게임 강국답게 한국에는 유료,무료의 네트웍 라이브러리가 있습니다.


유료용으로는 프라우드넷( http://nettention.co.kr/kr/ )이라는 것이 있습니다.

다양한 프로젝트에서 사용되어 높은 신뢰성과 편리하고특다양한 기능을 가지고 있으며 특히 P2P에서 아주 강합니다.


( 프라우드넷을 사용한 유명한 게임으로는 넥슨의 마비노기 영웅전이 있습니다)


그리고 무료용으로는 HalfNetwork( http://code.google.com/p/halfnetwork/ )OCF( http://ocf.kr/ ) 등이 있습니다. 둘 다 실제 게임 개발에서 사용하고 있는 것으로 신뢰도가 높다고 할 수 있습니다.





이 중 HalfNetwork의 개발에는 저도 아주 조금이나마 참여를 하고 있어서 HalfNetwork를 사용하여 C#으로 간단한 서버 프로그램(아주 간단한 네트웍 기능만 가지고 있는)을 만들어 보겠습니다.

 

그럼 HalfNetwork에 대한 설명은 다음 회에 하겠습니다.

 

MSDN을 보다 보니 C++/CLI의 델리게이트에 네이티브용 함수를 할당할 수 있는 방법이 있어서 소개합니다. 아래의 코드는 MSDN에 있는 것입니다.

 

#pragma unmanaged

extern "C" void printf(const char*, ...);

class A {

public:

   static void func(char* s) {

      printf(s);

   }

};

 

#pragma managed

public delegate void func(char*);

 

ref class B {

   A* ap;

 

public:

   B(A* ap):ap(ap) {}

   void func(char* s) {

      ap->func(s);

   }

};

 

int main() {

   A* a = new A;

   B^ b = gcnew B(a);

   func^ f = gcnew func(b, &B::func);

   f("hello");

   delete a;

}

< http://msdn.microsoft.com/ja-jp/library/9cy3ccxx%28v=VS.80%29.aspx >

 

위 코드 중 #pragma unmanaged 지시어 이하는 컴파일러에서 비관리코드로 취급합니다. 그리고 #pragma managed 이하는 관리코드로 취급합니다. 내용이 간단하고 어려운 부분이 없기 때문에 따로 자세한 설명은 생략하겠습니다.

 


C++/CLI는 단순하게 닷넷 플랫폼에서 사용할 수 있는 C++ 언어라기 보다는 C++ 언어의 부족한 부분을 진화 시킨 언어라고도 생각할 수 있는 부분이 꽤 있습니다. 그러나 C++/CLI는 C++과 C#의 중간의 애매한 위치에 있어서 양쪽 프로그래머 모두에게 별로 호응을 받지 못하는 것 같습니다. 그래서 C++/CLI 관련 글을 제가 처음에 생각했던 것보다는 조금 일찍 끝낼려고 합니다.

C++/CLI를 사용하는 대부분의 프로그래머들은 아마 기존의 비관리 코드를 관리코드에서 사용하고 싶을 때라고 생각합니다. C++/CLI의 기능 소개는 이번으로 일단 끝내고 앞으로는 비관리코드와의 연계에 대해서 실제 사례 보여주면서 설명하려고 합니다.


사례는 오픈 소스 네트워크 라이브러리인 HalfNetworkC++/CLI를 사용하여 관리코드에서 사용할 수 있도록 wrapping한 후 이것을 관리코드에서 사용할 예정입니다.

HalfNetwork는 온라인 게임 서버 프로그래머인 임영기님이 만든 것으로 ACE 라는 오픈 소스 네트워크 라이브러리를 사용하기 편하게 만든 라이브러리입니다.

 

소스 위치 http://code.google.com/p/halfnetwork/

문서 http://code.google.com/p/halfnetwork/w/list http://jacking.tistory.com/category/HalfNetwork

임영기님 블로그 http://javawork.egloos.com/

 

요즘 공부할 것은 너무 많은데 따라갈 시간은 부족해서 다음 글은 언제쯤 올리지 정확하게 알 수 없지만 최대한 빨리 다음 글들을 올려서 C++/CLI을 2010년 안에는 끝내고 내년에는 새로운 주제로 시작하겠습니다^^