[ VC11-C++11 ] range base for - 1

C++0x 2012. 8. 21. 19:20 Posted by 알 수 없는 사용자

VC10에서 선보였던 C++11의 기능 중 강력하면서 사용하기 쉽고, 자주 사용한 기능이 아마 'auto'이지 않을까 생각합니다. 예전에 강연을 할 때 auto와 관련된 예제를 보여드리면 많은 분들이 아주 좋아하시더군요(좀 놀라기도 하시더군요^^). 어떤 분들은 딴 건 제쳐두고 이것 때문이라도 VC10을 사용해야겠다는 분들이 있었습니다.

 

이번 VC11에서도 'auto'와 같은 강력한 기능이 있습니다. 바로 'range base for' 입니다. 이것을 사용하면 반복문을 아주 쉽고, 강력하게 사용할 수 있습니다.

VC 특화 기능인 for each와 비슷하기 때문에 기존에 for each를 사용하고 있다면 이제는 range base for로 쉽게 바꾸어서 사용하면 됩니다.

 

 

예제를 통해 일반적인 for , VC for each, range base for문의 차이를 예제를 통해서 보겠습니다.

 

< 예제. 1 >

#include <iostream>

int main()

{

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

 

          

           std::cout << "일반적인 for " << std::endl;

          

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

           {

                     std::cout << i << std::endl;

           }

 

 

           std::cout << "VC++ 특화의 for each" << std::endl;

 

           for each( int i in NumberList )

           {

                     std::cout << i << std::endl;

           }

 

 

           std::cout << "range base for " << std::endl;

 

           for( auto i : NumberList )

           {

                     std::cout << i << std::endl;

           }

 

           return 0;

}

 

< 실행 결과 >


<예제.1>을 보면 일반적인 for 문은

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

와 같이 시작과 종료 조건, 증가 값 이렇게 3개의 조건에 의해서 반복 됩니다.

 

그러나 range base for문은 VC만의 반복문인 for each와 비슷하게 데이터셋 변수와 이 데이터셋 요소의 타입을 선언하면 됩니다.

for( auto i : NumberList )

 

기존의 for 문에 비해서 또는 for each 보다도 간편해졌고, for each는 표준이 아닌 VC만의 기능인 것에 비해서 range base for C++ 표준 기능입니다.

 

range base for 문의 문법은 아래와 같습니다.

for ( for-range-declaration : expression ) statement

  

range base for 덕분에 반복문의 사용이 쉬워졌고, for 문을 사용할 때 종료 조건이 잘못되어 메모리 침범을 하는 위험도 피할 수 있게 되었습니다.

[ VC11-C++11 ] chrono - clock 클래스

C++0x 2012. 8. 14. 09:00 Posted by 알 수 없는 사용자

이번은 chrono clock 클래스에 대해서 간단하게 설명 하겠습니다.

앞의 글들을 보신 분 들은 아시겠지만 이미 clock 클래스를 사용하고 있었습니다.

 

다만 저는 현재까지는 system_clock 이라는 클래스만을 사용하고 있었습니다.

 

chrono에는 system_clock뿐만 아닌 steady_clock high_resolution_clock이 있습니다.

 

 

namespace std {

 

namespace chrono {

 

  class system_clock;

 

}}

 

 

namespace std {

 

namespace chrono {

 

  class steady_clock;

 

}}

 

   

 

namespace std {

 

namespace chrono {

 

  class high_resolution_clock;

 

}}

 

 

system_clock는 가장 일반적으로 사용하는 것으로 시스템 시간을 표현하기 위한 시간입니다.

그리고 C 런타임의 time_t와 호환성을 가지고 있습니다.

 

멤버 중에 to_time_t from_time_t가 있는데 이름을 보면 알 수 있듯이

to_time_t system_clock::time_point time_t로 변환하고,

from_time_t time_t system_clock::time_point로 변환 합니다.

 

 

// to_time_t

system_clock::time_point CurTime = system_clock::now();

std::time_t t = system_clock::to_time_t(CurTime);

 

// from_time_t

std::time_t t = time(NULL);

system_clock::time_point CurTime = system_clock::from_time_t(t);

 

 

steady_clock은 물리적인 시간처럼 결코 역행하지 않는 시간을 나타내기 위한 시간입니다.

이 말은 steady_clock 이외의 clock 클래스는 time_point를 얻은 후 os에서 날짜를 과거를 되돌린 후 time_point을 얻으면 앞에 얻은 시간보다 과거의 시간이 얻어지는데 steady_clock에서는 절대 그렇지 않습니다. 그래서 시간의 흐름이 바뀌지 않는 시간을 얻고 싶을 때는 steady_clock을 사용합니다.

 

 

high_resolution_clock는 해당 플랫폼(Windows 또는 Linux )에서 가장 짧은 단위의 시간입니다.

이 클래스는 system_clock steady_clock의 다른 별칭으로 정의되기도 합니다.

 

 

 

보통 프로그래밍에서 아주 고해상도의 시간 단위가 아닌 경우 대부분 GetTickCount() 함수를 사용했는데(Windows에서) 앞으로는 더 간단하고 다양한 표현 방법으로 시간을 다룰 수 있는 chrono를 꼭 사용해 보시기 바랍니다^^

 

[ VC11-C++11 ] chrono - 시간 계산

C++0x 2012. 8. 7. 09:00 Posted by 알 수 없는 사용자

<예제.2>에서 보았듯이 chrono는 다양한 정밀도 타입으로 시간을 표시할 수 있습니다.

 

그리고 각 시간 정밀도 타입 별로 생성할 때 미리 값을 설정할 수 있습니다.

 

std::chrono::hours H1(1);

std::chrono::seconds S1(10);

std::chrono::milliseconds MILS1(100);

 


또한 이 시간 타입을 서로 연산할 수도 있습니다.

 

std::chrono::hours H1(1);

std::chrono::hours H2(2);

std::chrono::hours H3 = H1 + H2;

 


물론 다른 시간 타입을 연산할 수도 있습니다

 

std::chrono::seconds S1(10);

std::chrono::milliseconds MILS1(100);

std::chrono::milliseconds MILS2 = S1 + MILS1;

 

다른 시간 타입을 연산할 때 주의할 점이 있습니다. 아래처럼

 

std::chrono::milliseconds MILS2 = S1 + MILS1;

 

의 경우는 초와 밀리초라는 서로 다른 타입을 더하지만 값을 저장하는 타입이 밀리초이기 때문에 잃어버리는 값이 발생하지 않으므로 연산에 문제가 없습니다.

 

그러나 아래와 같이

std::chrono:: seconds S2 = S1 + MILS1;

로 하는 경우는 밀리초 부분을 잃어버리게 되기 때문에 컴파일 에러가 발생합니다.

 

이런 경우는 명시적으로 형 변환을 시켜줘야 합니다.

 

std::chrono::seconds S2 = std::chrono::duration_cast< std::chrono::seconds >(S1 + MILS1);

 

 

< 예제. 3 >

#include <chrono>

#include <iostream>

 

int main()

{

    {

        std::chrono::hours H1(1); // 1시간

       

        std::cout << "H1(1) : " << H1.count() << std::endl;

        

        std::chrono::seconds S1(10);

        std::chrono::seconds S2(120);

 

        std::cout << "S1(10) : " << S1.count() << std::endl;

        std::cout << "S2(120) : " << S2.count() << std::endl;

    }

 

    {

        std::chrono::hours H1(1);

        std::chrono::hours H2(2);

        std::chrono::hours H3 = H1 + H2;

 

        std::cout << "H1 + H2 = : " << H3.count() << std::endl;

  

        std::chrono::seconds S1(10);

        std::chrono::milliseconds MILS1(100);

        std::chrono::milliseconds MILS2 = S1 + MILS1;

 

        std::cout << "S1 + MILS1 = : " << MILS2.count() << std::endl;

  

        std::chrono::seconds S2 = std::chrono::duration_cast< std::chrono::seconds >(S1 + MILS1);

 

        std::cout << "S1 + MILS1 = : " << S2.count() << std::endl;

    }

 

    return 0;

}

 

< 실행 결과 >


[ VC11-C++11 ] chrono - 시간 측정하기

C++0x 2012. 7. 31. 10:41 Posted by 알 수 없는 사용자

chrono는 C++11에서 새로 추가된 시간 라이브러리입니다. 기존의 C 런타임에서 제공하는 time 함수에 비해서 다양한 기능이 있고, 사용이 쉽고 정밀도는 훨씬 높습니다. time 함수는 초 단위의 값만 측정할 수 있는 것에 비해 chrono는 나노 밀리 초 단위도 측정할 수 있습니다.

 

현재의 C++(C++03)에서는 초 단위보다 더 정밀한 단위로 시간을 측정할 때는 OS에서 제공하는 API를 사용해야 했는데 chrono를 사용하면 OS 독립적으로 높은 단위의 시간을 측정할 수 있습니다.

 

VC10에서는 chrono가 들어가지 않았지만 이번 VC11에서 chrono STL에 들어갔습니다. 만약 VC11을 사용하지 못하는 경우라면 Boost 라이브러리를 사용하면 사용할 수 있습니다.

 

chrono를 사용하면 특정 시간 구간에 걸린 시간을 초, 밀리 초, 나노 초 단위로 얻을 수 있으며 또 시간끼리 연산을 할 수 있습니다

 

 

 

chrono 사용 방법

 

chrono를 사용하기 위해서는 아래의 헤더 파일을 추가합니다.

#include <chrono>

 

 

chrono에 대한 자세한 설명에 앞서 어떤 기능인지 좀 더 쉽게 알 수 있도록 예제를 하나 보여드리겠습니다. 아래의 예제는 어떤 함수의 성능을 측정하기 위해서 chrono를 사용했습니다.

 

 

< 예제. 1 >

#include <chrono>

#include <iostream>

#include <cmath>

 

 

void Test()

{

           for ( long i = 0; i < 10000000; ++i )

           {

                     std::sqrt( 123.456L );

           }

}

 

 

 

int main()

{

 

    std::chrono::system_clock::time_point start = std::chrono::system_clock::now();

 

    Test();

          

    std::chrono::duration<double> sec = std::chrono::system_clock::now() - start;

 

    std::cout << "Test() 함수를 수행하는 걸린 시간() : " << sec.count() << " seconds" << std::endl;

 

    return 0;

}

 

< 실행 결과 >


 

<예제.1>에서는 std::chrono::system_clock::now()을 사용하여 현재 시간을 얻습니다.

 std::chrono::system_clock::time_point start = std::chrono::system_clock::now();

여기서 time_point 타입은 시간 상의 한 축을 뜻합니다.

 

 

 

이후 Test() 함수를 실행한 후 다시 현재 시간을 얻은 후 Test()를 시작하기 전에 저장한 현지 시간을 빼면 Test()를 수행하는 걸린 시간을 얻을 수 있습니다.

 

std::chrono::duration<double> sec = std::chrono::system_clock::now() - start;

  

* std::chrono::system_clock::now()에 의해서 얻는 시간의 초기 시간은 1970년 입니다.

 

 

 

시간 단위

chrono는 경과 시간을 계산할 때 다양한 시간 타입으로 계산할 수 있습니다.

 

<예제.1>에서는 초 단위의 정밀도로 소수점까지 표시할 수 있었습니다.

 

std::chrono::duration<double> sec = std::chrono::system_clock::now() - start;

 

그런데 보통은 소수점이 나오는 결과 값보다는 정수로 나오는 값을 사용하는 경우가 많을 것입니다.

 

 

chrono에서는 경과 시간을 나타내는 클래스는 duration입니다.

duration 6개의 시간 단위를 지원합니다.

 

std::chrono::nanoseconds  // 나노 세컨드. 10억분의 1

std::chrono::microseconds // 마이크로 세컨드. 100만분의 1

std::chrono::milliseconds   // 밀리 세컨드. 1000분의 1

std::chrono::seconds        //

std::chrono::minutes         //

std::chrono::hours           //

 

<예제.1>을 수정하여 위에 열거한 chrono의 다양한 단위를 사용하여 시간 측정을 해 보겠습니다.

 

< 예제. 2 >

#include <chrono>

#include <iostream>

#include <cmath>

 

 

void Test()

{

           for ( long i = 0; i < 10000000; ++i )

           {

                     std::sqrt( 123.456L );

           }

}

 

int main()

{

    std::chrono::system_clock::time_point StartTime = std::chrono::system_clock::now();

          

    Test();

 

    std::chrono::system_clock::time_point EndTime = std::chrono::system_clock::now();

 

 

 

    std::chrono::duration<double> DefaultSec = EndTime - StartTime;

 

    std::chrono::nanoseconds nano = EndTime - StartTime;

 

    std::chrono::microseconds micro = std::chrono::duration_cast<std::chrono::microseconds>(EndTime - StartTime);

 

    std::chrono::milliseconds mill   = std::chrono::duration_cast<std::chrono::milliseconds>(EndTime - StartTime);

 

    std::chrono::seconds sec                   = std::chrono::duration_cast<std::chrono::seconds>(EndTime - StartTime);

 

    std::chrono::minutes min                  = std::chrono::duration_cast<std::chrono::minutes>(EndTime - StartTime);

 

    std::chrono::hours hour                              = std::chrono::duration_cast<std::chrono::hours>(EndTime - StartTime);

 

 

 

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << DefaultSec.count() << " default" << std::endl;

 

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << nano.count() << " nanoseconds" << std::endl;

 

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << micro.count() << " microseconds" << std::endl;

 

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << mill.count() << " milliseconds" << std::endl;

 

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << sec.count() << " seconds" << std::endl;

 

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << min.count() << " minutes" << std::endl;

 

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << hour.count() << " hour" << std::endl;

          

    return 0;

}

 

< 실행 결과 >


[ VC11-C++11 ] enum - 전방선언

C++0x 2012. 7. 23. 09:00 Posted by 알 수 없는 사용자

unscoped enumeration scoped enumeration 둘 다 전방 선언을 할 수 있습니다.

 

아래와 같이합니다.

enum ITEMTYPE : short;

enum class CHARACTER_CLASS : short;

 

전방 선언을 할 때 unscoped enumeration은 타입 선언을 생략할 수 없지만 scoped enumeration은 타입 선언을 생략 할 수 있습니다.

 

아래 예제 코드를 보면 전방 선언을 올바르게 사용한 것과 잘못 사용한 예를 볼 수 있습니다.


< TypeDef.h >

 

#pragma once

 

enum ITEMTYPE : short

{

           WEAPON,

           EQUIPMENT,

           GEM                          = 10,

           DEFENSE,

};

 

enum class CHARACTER_CLASS1 : short

{

           WARRIOR                    = 1,     

           MONK,

           FIGHTER,

};

 

enum class CHARACTER_CLASS2

{

           WARRIOR                    = 1,     

           MONK,

           FIGHTER,

};

 

 

 

 

 

< Character.h >

 

#pragma once

 

enum ITEMTYPE : short;

//enum ITEMTYPE;                                          // 에러

//enum class ITEMTYPE : short;                       // 에러

 

 

enum class CHARACTER_CLASS1 : short;

//enum class CHARACTER_CLASS1;                  // 에러

//enum class CHARACTER_CLASS1 : int;           // 에러

//enum CHARACTER_CLASS1 : short;                // 에러

 

 

enum class CHARACTER_CLASS2;

 

 

 

struct Character

{

           ITEMTYPE m_ItemType;

          

           void SetItemType( ITEMTYPE Type );

 

 

           CHARACTER_CLASS1 m_Class;

          

           void SetClass( CHARACTER_CLASS1 CharClass );

};

 

 

 

 

< Character.cpp >

 

#include "Character.h"

#include "TypeDef.h"

 

 

void Character::SetItemType( ITEMTYPE Type )

{

           m_ItemType = Type;

}

 

void Character::SetClass( CHARACTER_CLASS1 CharClass )

{

           m_Class = CharClass;

}

 

 

[ VC11-C++11 ] enum - unscoped enumeration과 scoped enumeration

C++0x 2012. 7. 16. 09:00 Posted by 알 수 없는 사용자

C++11(새로운 C++ 표준의 이름) enum은 지금(C++03)과 다르게 두 가지의 enum이 있습니다.

바로 unscoped enumerationscoped enumeration 입니다.

 

 

unscoped enumeration

unscoped enumeration은 기존의 enum과 비슷한 것 이라고 생각 하면 좋을 것 같습니다.^^

 

 

unscoped enumeration은 아래와 같이 정의하고 사용합니다.

 

enum ITEMTYPE : short

{

   WEAPON,

   EQUIPMENT,

   GEM       = 10,

   DEFENSE,      // C++03까지는 에러이지만 C++11에서는 에러가 아님

};

 

사용은 아래와 같이

short ItemType = WEAPON;

 또는

short ItemType = ITEMTYPE::WEAPON; // C++03에서는 에러

 

 


scoped enumeration 

scoped enumeration은 아래와 같이 정의하고 사용합니다.

enum class CHARACTER_CLASS : short

{

           WARRIOR                    = 1,     

           MONK,

           FIGHTER,

};

 

사용은 아래와 같이 합니다.

CHARACTER_CLASS CharClass = CHARACTER_CLASS::WARRIOR;

 

그러나 아래는 에러입니다.

short CharClassType = FIGHTER; // 에러

 

scoped enumeration unscoped enumeration와 다르게 CHARACTER_CLASS를 생략하면 안됩니다. WARRIOR 이나 MONKCHARACTER_CLASS의 범위 안에 있음을 가리킵니다.

 

그리고 enum class 대신 enum struct을 사용해도 괜찮습니다. 타입을 지정하지 않으면 기본으로 int 타입이 됩니다.

 

 

 

형 변환

unscoped enumeration은 기존과 같이 암묵적으로 정수로 변환할 수 있습니다.

int i = WEAPON;

 

그러나 scoped enumeration은 명시적으로 타입 캐스팅을 해야합니다.

int i = static_cast<int>( CHARACTER_CLASS::WARRIOR);

 

 

 

< 예제 >

#include <iostream>

 

// unscoped enumeration

enum ITEMTYPE : short

{

           WEAPON,

           EQUIPMENT,

           GEM                          = 10,

           DEFENSE,

};

 

// scoped enumeration

enum class CHARACTER_CLASS : short

{

           WARRIOR                    = 1,     

           MONK,

           FIGHTER,

};

 

enum struct BATTLE_TYPE : short

{

           DEATH_MATCH              = 1,     

           TEAM,

};

 

int main()

{

           // unscoped enumeration

           std::cout << "ITEM WEAPON Type 번호 : " << ITEMTYPE::WEAPON << std::endl;

 

           short ItemType = EQUIPMENT;

           std::cout << "ITEM EQUIPMENT Type 번호 : " << ItemType << std::endl;

 

 

 

           /// scoped enumerations

           short CharClassType3 = (short)CHARACTER_CLASS::FIGHTER;

 

           CHARACTER_CLASS CharClass = CHARACTER_CLASS::WARRIOR;

          

           //short   CharClassType    = FIGHTER;                                  // 에러                                           

 

           //short   CharClassType2   = CHARACTER_CLASS::FIGHTER; // 에러

          

           //CHARACTER_CLASS       CharClass2    = WARRIOR;            // 에러

                            

           return 0;

}

 

 

[ VC11 ] 메모리를 절약하는 VC++11의 STL 컨테이너

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

VC11 STL 컨테이너들은 이전 버전에 비해서 크기가 작아져서 메모리를 절약할 수 있게 되었습니다. 이전 버전과 다르게 VC11부터는 데스크탑 뿐만이 아닌 테블렛이나 스마트폰의 모바일 플랫폼 개발에서도 사용되므로 메모리 절약은 적지 않은 도움이 되리라 생각합니다.

 

아래 표는 x86(32비트 또는 ARM) x64(64비트) 플랫폼에서 각 VC 버전 별로 얼마만큼의 메모리를 사용하는 잘 표시하고 있습니다.

 

이 표는 VC11 뿐만이 아닌 이전 버전 사용자들에게도 도움이 될 것 같습니다. 저와 같은 서버 프로그래머들은 서버 프로그램이 설정한 동접자 수에서 어느 정도의 메모리를 소비할지 어느 정도 계산하고 있어야 하는데 이 표를 보면 메모리 계산할 때 도움이 될 것입니다

 

표의 바이트 사이즈는 Release 버전 기준입니다. 표에서 'VC9 SP1 SCL=0'SCL _SECURE_SCL를 뜻하는 것으로 원래 SCL은 기본은 1인데, 최고 스피드를 위해서 수동으로 SCL0으로 설정한 것입니다. VC10 VC11에서는 기본으로 _SECURE_SCL 0으로 되어 있습니다.

 



표의 출처는 MSDN입니다^^





[ VC11 ] 대격변(?) Visual C++ 11

Visual C++ 10 2012. 6. 25. 09:00 Posted by 알 수 없는 사용자

드디어 Visual Studio 2012(이하 VS2012) RC판이 나왔습니다(사실 꽤 되었죠^^;). 

이번 VS Visual C++(이하 VC++)의 버전은 11이 됩니다.

 

한동안 Visual C++은 변화가 거의 없다가 VC++ 9(VS 2008)에서 변화의 조짐을 보이다가 VS 2010에서 새로운 C++ 표준인 C++11(그 당시에는 C++0x라고 부름)과 병렬 프로그래밍, 툴의 기능 강화를 통해서 이전에 비해서 큰 변화를 이루었습니다.

또 이번 VS 2012에서도 VS 2010 버전 이상으로 큰 변화가 생겼습니다. 변화는 대격변이라고 부를 수 있을 정도입니다!.

 

 

이번에는 다음과 같은 변화가 있습니다.

 

1. Windows 8 Metro 앱 개발

아주 큰 변화 중의 하나입니다. 정식 제품이 가을쯤에 나올 Windows 8 Metro Windows Phone 8용 앱을 C++을 사용하여 개발할 수 있습니다. 이것을 위해 WinRT라는 새로운 플랫폼 API C++/CX가 새로 생겼습니다.

 

2. 툴 기능

다양한 C++ 토큰들에 다양한 색을 지정.

찾을 요소를 눈에 잘 뛰게 해준다.

편의 기능이 코딩 시 멤버 선택.

인텔리센스에서 C++/CLI 지원.

코드스니펫을 이용한 고속 코딩.

 

3. C++11 지원

이번에는 코어 언어 기능 보다는 라이브러리 기능이 더 중심이 되었습니다. 그러나 코어 언어에서 VC++ 10에서 큰 사랑을 받은 auto에 버금가는 range-based for loop가 있습니다. 그리고 라이브러리에 Thread가 추가 되었습니다. 이번에는 공부할 것이 많습니다 ^^;

 

4. 컴파일러 개선

CPU 개수에 맞추어 컴파일 속도가 향상.

Auto-Vectorizer 의한 프로그램 성능 향상.

 

5. 병렬 프로그래밍

기존의 병렬 라이브러리 개선.

새로운 디버깅 및 시각화 기능에 의해 쉽고 올바른 병렬 프로그래밍 진단.

GPU 병렬 프로그래밍을 위한 C++ AMP 추가.

 

6. 네이티브 유닛테스트 프레임웍 추가

사제가 아닌 마이크로소프트 순정의 유닛테스트 프레임웍!!!.

 

 

 

이렇게 VC++ 11의 새로운 기능을 정리해 보았습니다. 제가 대충 큰 것만 정리했는데도 공부할 것이 많지 않습니까?^^; 한번에 다 하면 부담되지만 조금씩 하면 충분히 공부할만한 분량입니다. 아직 정식 버전이 나오지 않았으니(가을쯤에 나온다고 합니다) 여유를 가지고 지금부터 조금씩 천천히 공부해 보죠^^

 

 

 

 

 

ps 1: VC++의 각 버전 별 내부 버전 번호와 코드에 정의된 버전

브랜드 버전                  내부 버전          #define _MSC_VER 버전

Visual C++ 2005            VC8                 1400

Visual C++ 2008            VC9                 1500

Visual C++ 2010            VC10                1600

Visual C++ 2012            VC11                1700

 

 

ps 2: 실행 환경

위에는 VC++11의 좋은 점만 이야기 했지만 개인적으로 걱정되는 것이 있습니다. 가장 큰 문제가 실행 환경입니다. VC++11Windows Vista 이상에서만 실행되고 또 VC++11을 이용해서 만든 프로그램도  Windows Vista  이상에서만 실행할 수 있습니다.

Windows 8 Metro 앱 개발을 하거나 저처럼 서버 개발을 하는 개발자에게는 큰 문제가 되지 않을 수도 있지만 클라이언트 개발자에게는 이 부분이 VC++11을 사용하는데 큰 걸림돌이 되리라 생각합니다

 => 그런데 VC++ 팀블로그를 보니 많은 고객들이 XP 지원을 요청해서 가을쯤에 업데이트를 통해서 XP도 지원해 준다고 합니다.^^ 

http://blogs.msdn.com/b/vcblog/archive/2012/06/15/10320645.aspx

이로써 큰 고민을 하나 해결 되었네요^^

 

Visual C++ 10에서 디버깅하기

Visual C++ 10 2012. 4. 25. 00:28 Posted by 알 수 없는 사용자

예전에 Visual C++ 10과 관련된 책을 집필할 계획이 있어서 그때 작성한 글인데 책 출간 계획이 사라졌으므로(한참 전에)

그냥 공개합니다. 글은 초보자를 타겟으로 하고 있으며 Visula C++ 10의 디버깅 기능을 설명하고 있습니다.


도움이 되었으면 좋겠습니다^^



6장 디버깅.pdf


문서를 동의 없이 수정하지 않고, 출처만 남겨 주신다면 문서는 마음대로 배포하셔도 괜찮습니다^^


개발자에게 Visual Studio 11의 가장 큰 장점 중에 하나가 될 바로 코드 에디터 입니다. 특히 C++ 개발자에게 원성을 샀던 부실했던 C++ 코드 에디터는 기존의 C,#, VB.NET 과 동등할 정도로 코드 에디터의 구현에 충실해 다른 확장 도구의 도움 없이도 충분히 사용이 가능합니다. (Visual C++ 의 코드 에디터는 그 흔한 코드 컬러링도 기대 이하의 수준이었거든요)

   

C++ 코드 에디터

C++ 개발자에게는 C++ 코드 편집기의 컬러링과 인텔리센스는 정말 희소식일 것 같습니다. C++ 개발자는 기본적인 코드 작성에 Visual Assist 툴에 많이 의존하였었지만, 이제 외부 도구의 도움이 없이도 코드 작성에 어려움은 없을 것 같습니다. 

아래의 Visual Studio 2010과 Visual Studio 11의 C++ 코드 에디터를 그냥 눈으로 쓱 훑어보시기 바랍니다.

   

Visual Studio 2010의 C++ 코드 에디터

   

Visual Studio 11의 C++ 코드 에디터

   

   

   

C++/CLI 코드 에디터

특히 C++/CLI 를 자주 쓰는 분들에게는 더욱 특별할 수 있을 겁니다. C++/CLI 는 이전버전까지 예쁜 컬러링은 물론이거니와 인텔리센스도 작동하지 않는 암울한 환경에서 코드를 작성해야 했었습니다. 특히 C++/CLI 를 이용하여 C++ 코드를 단위 테스트할 때 무척 유용하였는데, 이번 컬러링과 인텔리센스 기능으로 더욱 활용도가 높아질 것 같습니다.

마찬가지로 Visual Studio 2010의 C++/CLI와 Visual Studio 11의 C++/CLI의 코드 에디터를 한번 보시죠.

   

Visual Studio 2010 C++/CLI 코드 에디터

   

Visual studio 11 C++/CLI 코드 에디터

C#, VB.NET 과 동급한 레벨로 인텔리센스와 코드 컬러링을 제공합니다. 그리고 Code Snippet도 제공되니 코딩이 한껏 즐거워지겠네요.

   

   

   

JavaScript 코드 에디터

JavaScript 는 웹 개발 환경에서 필수 언어로써, 개발 툴에서 JavaScript 인텔리센스 지원이 점점 좋아지고 있네요. Visual Studio 11 Beta 에서는 JavaScript 인텔리센스의 성능이 향상이 되거나 HTML5 등을 지원하는데요.

그 중, Lazy Initialize와 Lazy Loading 부분에서 상당히 만족할만한 수준으로 인텔리센스 기능이 좋아졌습니다.

   

JavaScript 코드 에디터에 대한 더 자세한 내용은 다음의 링크를 참고하십시오.

http://msdn.microsoft.com/en-us/library/bb385682(v=vs.110).aspx

   

JavaScript 코드 에디터의 인텔리센스가 얼마나 똑똑해 졌는지 아래의 예시를 보면서 비교해 보시기 바랍니다.

   

Visual Studio 2010 JavaScript 인텔리센스

인텔리센스가 C#, VB.NET 과 다르게 인텔리센스의 범위가 축소가 되지 않고 그냥 다~~~ 보여주지요.

   

   

Visual Studio 11 JavaScript 인텔리센스

JavaScript 인텔리센스가 C#, VB.NET 에서 사용하는 것과 똑같이 입력하는 문자에 따라 점점 인텔리센스 범위가 축소가 됩니다. 그리고 인텔리센스 상자 오른쪽에 시그너처도 함께 표시해 주네요.

   

   

JavaScript OOP 프로그래밍 인텔리센스

특히 JavaScript OOP 프로그래밍을 할 때는 인텔리센스의 도움을 많이 받게 되지요. Visual Studio 11 의 JavaScript 구문을 제대로 분석하여 인텔리센스를 제공해 주는 것 또한 막강한 Visual Studio 11 기능이라고 할 수 있습니다.

특히 Visual Studio 2010을 사용할 때 필자는 JavaScript OOP 프로그래밍을 절대 Visual Studio 2010에서 하지 않았답니다. 왜냐하면 제대로 인텔리센스를 보여주지 못하거나 올바른 인텔리센스 목록이 제공이 되지 않으면, 아차 하는 순간 코드가 동작을 안하거든요.

   

마찬가지로 Visual Studio 2010과 Visual Studio 11의 JavaScript OOP 인텔리센스를 비교해보시죠.

   

Visual Studio 2010 JavaScript OOP 인텔리센스

아주 간단한 JavaScript Initialize 패턴과 Simple Factory 패턴의 New() 메서드를 인식하지 못합니다. 물론 아래의 코드는 잘못된 코드가 아니겠지요.

   

Visual Studio 11 Beta JavaScript OOP 인텔리센스

Visual Studio 2010 JavaScript 인텔리센스에 비해 Visual Studio 11 Beta 는 Lazy Initialize 패턴과 Simple Factory 패턴 구문을 정확하게 분석하여 인텔리센스 목록에 New() 메서드를 깔끔하게 보여주고 있습니다.

   

   


[미리 보는 C++11] 8. Placement Insert

C++0x 2012. 2. 27. 09:00 Posted by 알 수 없는 사용자

Placement Insert C++11의 기능 중에 하나로 STL 컨테이너와 관계가 있습니다.

 

struct ITEM

{

ITEM( int nCode )

{

}

};

 

std::vector< ITEM > Items;

Items.push_back( ITEM( 1 ) );

 

현재까지는 위 코드처럼 ITEM이라는 객체를 Items 컨테이너에 생성과 동시에 추가를 할 때는 위와 같이해야 합니다. 그런데 위 방식으로 하면 추가를 위해 컨테이너에 한번 생성을 한 후 복사를 해야 하는 문제가 발생합니다(또 임시 객체 만들므로 삭제 비용도 발생합니다).

이와 같은 동작은 우리가 원하는 것이 아닙니다.

그래서 C++11에서는 이와 같은 문제를 해결했습니다. 바로 Placement Insert가 해결했습니다.

 

C++11‘Placement Insert’를 사용하면 위의 코드는 아래와 같이 할 수 있습니다.

std::vector< ITEM > Items;

Items.emplace_back( 1 );

 

emplace_back push_back과 같지만 Placement Insert 기능이 구현된 것으로 임시 오브젝트를 만들면서 발생하는 비용을 없애줍니다.

 

C++11의 각 컨테이너에는 Placement Insert와 관련된 멤버로
emplace(insert),
emplace_back(push_back),
emplace_front(push_front),
emplace_hint(insert.
연관 컨테이너 용)
가 추가됩니다.

 

Placement InsertC++11의 새로운 기능인 가변 인수 템플릿을 사용하여 구현되었습니다.

 

 

Placement Insert는 아래와 같은 주의할 점도 있습니다.

1. explicit 문제.

   explicit 생성자도 암묵적으로 호출됩니다.


2. "0" 문제.

생성자의 파라미터가 포인터인 경우 인자로 0을 넘기면 int로 추론합니다. 그래서 이 경우에는 nullptr을 사용해야 합니다.

 

[미리 보는 C++11] 4. constexpr - 2

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

constexpr를 클래스에 사용


constexpr을 클래스에서 사용하면 클래스를 정수로 사용할 수도 있으며 메타 템플릿 프로그래밍에서는 이전에는 복잡하게 처리하던 것을 아주 간단하게 처리할 수도 있습니다. C++ 메타 템플릿 프로그래밍에 관심이 많구나 자주 사용하고 있는 분들에게는 constexpr 덕분에 프로그래밍이 한결 편해지리라 생각합니다.

 

아래의 코드는 Integer 이라는 클래스를 constexpr을 사용하여 정수처럼 사용 합니다.

class Integer

{

private :

    int value ;

 

public :

    constexpr Integer() : value() { }

    constexpr Integer( int value ) : value(value) { }

 

    constexpr operator int() { return value ; }

} ;

 

int main()

{

    constexpr Integer size = 5 ; // 컴파일 타임에 정수로

 

    int x[size] ; // Integer::operator int()가 호출된다

 

    Integer object ; // 일반적인 클래스 인스턴스 화. 실행 시에 처리

    int y[object] ; // 당근 에러

}

출처 : http://cpplover.blogspot.com/2010/11/gccniconstexpr.html

 


또 메타 템플릿 프로그래밍에서는 아래와 같이 사용할 수도 있습니다.

#include <iostream>

 

struct pi {

    static constexpr double value = 3.14;

};

 

template <const double& r>

struct circle_area {

    static constexpr double value = r * r * pi::value;

};

 

struct radius {

    static constexpr double value = 2.5;

};

 

int main()

{

    constexpr double result = circle_area<radius::value>::value;

 

    static_assert(result == 19.625, "not equal");

    std::cout << result << std::endl;

}

출처 : http://d.hatena.ne.jp/faith_and_brave/searchdiary?word=constexpr&.submit=%B8%A1%BA%F7&type=detail

 

 

constexpr은 컴파일 할 때 결과가 이미 결정 나는 것은 컴파일 타임 때 처리를 해주어 실행 시에 불필요한 처리를 막아주고, 기존의 메타 템플릿 프로그래밍으로 까다롭게 만들었던 것을 아주 쉽게 구현할 수 있게 해줍니다.

 

C++11에서는 constexpr을 잘 사용하면 기존 보다 더 뛰어난 프로그래밍을 할 수 있으니 깊게 파고들 가치가 있다고 생각합니다.

[미리 보는 C++11] 3. constexpr - 1

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

constexpr는 변수, 함수, 클래스를 컴파일 타임에 정수로 사용할 수 있도록 해줍니다. 즉 상수로 취급할 수 있는 작업은 컴파일 타임에 처리하도록 할 수 있습니다.

 

constexpr를 변수에 사용

constexpr int aa = 11;

이것은

const int aa = 11

와 같은 의미를 가집니다.

 

그러나 아래와 같이는 사용할 수 없습니다.

int input_num = 0;

constexpr int aa = input_num;  // 에러


constexpr
로 지정된 변수는 꼭 컴파일 시에 정수가 되기 때문에 변수 선언 시 대입이 정수 식이어야만 합니다. const와의 차이는 const는 컴파일 시에 정수가 아니어도 괜찮고 변수 선언 시 대입 값이 정수 식인 경우 정수 식이 되고, 그렇지 않은 경우는 단순히 const를 수식하는 것이 됩니다(이에 비해 constexpr는 꼭 정수 식이어야만 합니다).

 

 

 

constexpr를 함수에 사용

C++03에서는 아래의 코드는 에러가 됩니다.

int GetNum() { retun 5; }

int Numbers[ GetNum() ];

GetNum 함수는 상수 5를 반환 하는 것으로 이미 컴파일 시에 반환 값을 알 수 있습니다. 그러나 컴파일러는 GetNum 이라는 함수가 정수처럼 사용할 수 있는지 알 수 없으므로 정수로 취급하지 않습니다.

 

위 코드는 C++11constexpr를 사용하면 우리가 원하는 대로 GetNum 함수를 정수로 사용할 수 있습니다.

 

constexpr int GetNum() { retun 5; }

int Numbers[ GetNum() ];

 

constexpr를 함수에 사용할 때는 꼭 함수 본체는 { return expression; } 형태가 되어야만 합니다.

 

 

constexpr 변수는 비 constexpr 변수에 사용할 수 있으므로 아래와 같은 테크닉도 사용할 수 있다.

constexpr double power( double x, unsigned int y )

{

    return y == 1 ? x : x * power( x, y - 1 ) ;

}

 

int main()

{

    // 정수 식

    constexpr double a = power( 2, 32 ) ;

 

    // 정수 식이 아니다

    double x = 2 ; unsigned int y = 32 ;

    double b = power( x, y ) ;

}

(출처) http://cpplover.blogspot.com/2010/11/gccniconstexpr.html

 

 

그리고

const int base_HP = 200;

int NPC_Lv1_HP = base_HP + 0;

int NPC_Lv2_HP = base_HP + 200;

라는 코드는 정수 계산을 하는데 실행 시에 계산되는데 이것을 constexpr을 사용하여 컴파일 시에 계산되게 할 수 있습니다.

 

constexpr int AssignHP( int nPlusHP )

{

 return base_HP + nPlusHP;

}

 

int NPC_Lv1_HP = AssignHP( 0 );

int NPC_Lv2_HP = AssignHP( 200 );



 

[미리 보는 C++11] 2. override와 final

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

현재의 표준 C++에서는 부모 클래스의 특정 멤버를 오버라이드 할 때 virtual을 앞에 붙입니다.

struct Base

{

  virtual void foo( int i );

};

 

struct Derived : Base

{

  virtual void foo( int i );

}

 위의 예제와 같은 작은 코드를 만질 때는 실수를 하지 않지만 실제 일을 할 때는 크고 많은 클래스를 다루다 보면 실수를 할 수 있습니다. 위 예제의 경우 아래와 같은 실수를 할 수 있습니다.

struct Derived : Base

{

  virtual void foo( float i );

}

위와 같이 실수를 하면 Derived의 foo 멤버함수는 Base foo 멤버함수를 오버라이드 하지 않게 됩니다. 이런 실수는 에러가 아니기 때문에 골치 아픈 삽질을 할 수도 있습니다.

이런 문제를 방지하기 위해서 override가 새로 생겼습니다.

struct Derived : Base

{

  virtual void foo( float i ) override;

}

이렇게 override를 사용하게 되면 컴파일 할 때 Base 클래스에

void foo( float i )가 없는데 오버라이드 한다고 에러를 발생시켜 줍니다.

 

 

때로는 Base 클래스의 특정 멤버함수를 Derived 클래스에서 오버라이드 하지 못하도록 막고 싶은 경우가 있을 것입니다. 이때는 final을 사용합니다.

struct Base

{

  virtual void foo( int i ) final;

};

 

struct Derived : Base

{

  virtual void foo( int i );

}

위의 코드에서는 Base 클래스의 foo 멤버함수를 final로 오버라이드 못하도록 해 놓았기 때문에 컴파일을 하면 에러가 발생합니다.

 

 

 

참고

위키피디아 http://en.wikipedia.org/wiki/C%2B%2B0x

 

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

 

 

 

C++ AMP

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

C++ AMP라는 것을 들어보셨나요?근래에 나온 단어입니다.

AMP AcceleratedMassive Parallelism의 약자로 병렬 프로그래밍과 관련된 것입니다.

 

C++ AMP 2주 전의 AMD Fusion 컨퍼런스에서MicrosoftHerb Sutter씨가(MS의프로그램 언어 아키텍터 이자 C++ 표준 위원 멤버) 처음으로공개한 것으로 다음 버전의 Visual Studio(현재는Visual C++)에서 GPGPU 프로그래밍환경을 제공하는 것을 뜻합니다.

 

병렬 프로그래밍에서 대해서 조금 깊게 공부하신 분들은 아마 GPGPU라는것을 들어본 적이 있으리라 생각합니다. GPGPU는 간단하게 말하자면 GPU CPU 처럼 사용하자라는 것으로 GPU의 높은 성능을 사용하여 CPU와 똑 같게는 사용할 수는 없지만연산 처리에서 높은 병렬 기능을 사용하여 CPU보다 훨씬 뛰어난 결과를 얻을 수 있습니다.

 

현재까지 GPGPU 개발환경은NVIDIA Cuda와 오픈 아키텍처인 OpenCL,DirectX 베이스의 DirectCompute가 있습니다.

 

GPGPU 프로그래밍의 단점은 프로그래밍이 복잡하고 아직 레퍼런스가적다는 단점이 있어서 아직은 일반적인 프로그래밍 영역에 들어오지 못하고 있습니다(사실 아직 일반 병렬프로그래밍도 쉽게 사용하지 못하고 있으니..). 그래서 GPGPU가나온 것은 몇 년이 지났지만 아직 일부 전문 영역에서만 사용되고 있었습니다.

 

그러나 CPU 아키텍처가 멀티코어에서 헤테로지니어스 아키텍처(이기종의 CPU가 결합.CPU+GPU)로 서서히 넘어가고 있어서 자연스럽게GPGPU 프로그래밍이 부각되고 있었습니다. 하지만 아직도 개발환경의 뒷받침이 부족한 상태였는데드디어 우리 개발자에게 친숙한 Visual C++에서 이런 문제를 해결하려고 합니다.

 

C++ AMP는 쉽게 말하면Visual C++에서 GPGPU 프로그래밍을 지원하는 것을 말합니다. Visual C++의 뛰어난 개발환경을 토대로 하여 이때까지 복잡했던GPGPU 프로그래밍을 일반 프로그래밍 하듯이 사용할 수 있게 해줍니다. 이로써 GPGPU가 일반 프로그래밍 영역으로 들어 올 수 있는 큰 계기가 되었다고 생각합니다.

 

 

C++ AMP에 대해서 AMD Fusion 컨퍼런스에서 데모를 시연한 Daniel Moth의 블로그에올라온 글을 정리하면

개발자의 생산성과 이식성을 저해하지 않고 헤테로지니어스 하드웨어 프로그래밍의 허들을 낮게 하여 프로그래밍 일반영역에서 사용할 수 있도록 한다.

 

현재의 대 규모 병렬 하드웨어(CPU GPU)의 사용을 돕기 위한 것만이 아닌 코드의 투자를 미래에 대비한 디자인으로 하여 견고하도록 한다.

 

Visual Studio의 일부분으로 또 다른 컴파일러나 다른 구문을배울 필요가 없다.

 

현재의 C++ 언어를 사용하며 C나다른 파생 언어가 아니다.

 

Visual Studio vNext와 완벽하게 통합하여 지원한다. 편집, 빌드, 디버그, 프로파일러 등 Visual Studio의 다른 모든 기능이 C++ AMP와 같이 동작한다.

 

기존의 Concurrency Runtime의 일부로 STL와 비슷한 형태의 라이브러리를 제공하여 amp.h 헤더 파일을제공한다.

 

병렬화를 주 특징으로 하여 헤테로지니어스 하드웨어 위에서 거대한 다 차원 데이터를 아주 쉽게 동작한다.

 

유일의 코어 C++ 언어 확장을 도입한다.

 

DirectX(DirectCompute) 위에 구축하지만 C++ AMP에서는 DirectX의 모습은 나타나지 않는다( DirectX를 몰라도 상관 없다).

 

 

 

또 동 세미나에서 기조 연설을 한 Herb Sutter씨의 강연 중 C++ AMP에 관한 내용으로는

C++ AMP에 의해서 기존의C++에서 큰 변경을 가하지 않으면서 언어를 확장하는 점을 강조하여 새로운 언어가 만들어서 개발자에게 혼란을 주는 것을 피했다라는것을 알림.

 

언어 확장으로 restrict() 함수와 array_view라는 2개의 type Key로 잡음. restrict()는 프로세서 아키텍처에 따라서 실행가능한 기능에 제한을 거는 것이고 array_view는 불 균인한 메모리 공간으로의 접근으로 생기는문제를 회피하기 위한 것으로 메모리 공간을 N 차원의 배열로서 작업하는 것을 뜻한다. 메모리 공간의 추상화라고 할 수도 있다. restrict()array_view는 프로세서 아키텍쳐와 메모리 공간의 차이를 흡수할 수 있는 것으로 C++ AMP의 중요한 Key이다.

 

C++ AMP의 컴파일러는Visual Studio의 차기 버전에서 들어갈 예정으로 릴리스는 이번 연말로 예상하고 있다. 또이 컴파일러는 오픈 사양일 예정으로 Windows 상의 VisualStudio 뿐만이 아닌 그 이외의 개발 환경(C++ Builder이나 이클립스 등)에서도 이용할 수 있도록 AMD와 협력 하여 개발 중이라고 한다.

 

 

 

 

 

DirectXDirectCompute를 사용한다고 하니 C++ AMP를 사용한 프로그램은 Windows Vista 이상에서만 사용할 수 있을 것 같습니다(이유는 DirectCompute DirectX 10에서 지원하기 때문).

 

GPGPU에 관심은 있었지만 아직 시기상조라고 생각하는 분들은 C++ AMP가 나오면 개발 허들이 크게 내려가므로 본격적으로 준비를 해도 좋을 것 같습니다. AMD에서는 헤테로지니어스 컴퓨팅 프로그래밍의 전망을 CUDA 등의독자 사양에서 OpenCL이나 DirectCompute 등의오픈 사양으로 이동하고, 전문 프로그래머만 프로그래밍 하는 시대를2011년까지로 보고 그 이후로는 일반 프로그래머가 완전하게 C++로 프로그래밍하는 헤테로지니어스컴퓨팅 프로그램이 올 것으로 보고 있다고 합니다.

 

저도 이제 슬슬 GPGPU 프로그래밍 쪽으로 들어가볼 예정인데 일단조만간 OpenCL부터 시작해 볼까 합니다. 연말에 VS vNext가 나올 수도 있다고 하니 그때 꼭 C++ AMP를 공부해서 그 내용을 공유하도록 하겠습니다^^

 

 

 

참고

헤테로지니어스 멀티 코어 http://jacking.tistory.com/513

 

Daniel Moth씨의 블로그 http://www.danielmoth.com/Blog/

  위 글을 정리한 한블로그(일본어)
 http://blogs.msdn.com/b/hiroyuk/archive/2011/06/20/10176783.aspx

 

AMD Fusion 컨퍼런스에서의 데모

비디오 http://channel9.msdn.com/posts/Daniel-Moth-Blazing-fast-code-using-GPUs-and-more-with-C-AMP

슬라이드 http://ecn.channel9.msdn.com/content/DanielMoth_CppAMP_Intro.pdf

 

일본의 임프레스 사이트에 올라온 Herb Sutter씨의 기존 강연정리 글

http://pc.watch.impress.co.jp/docs/news/event/20110617_453939.html

 

[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의 세 번째 인자의 값이 시작 값이고, 이후에 값이 하나씩 증가합니다.