소개

GCC(GNU Compiler Collection)는 우리 중 대부분에게 C++ 컴파일러이며, 다음 C++0x 표준에서부터 기능을 지원하는 면에서 앞서 가고 있다(자세한 정보의 링크는 참고자료 참조). 이 기사는 정적 어설션, 초기화 프로그램 목록, 유형 축소 변환(type narrowing), 자동 키워드의 더 새로운 시맨틱, 람다 함수 및 가변인자(variadic) 템플리트를 비롯하여 GCC 버전 4.5를 지원하는 몇 가지 C++0x 기능의 서브세트에 주목한다. 이러한 일부 기능—예: 정적 어설션—은 먼저 GCC 버전 4.3에서 나타났지만, 람다 함수는 4.5 릴리스에 처음 나타났다. 독자가 C++0x를 일찍 받아들이고 싶다면, 초안 표준의 사본을 얻는 것을 생각해보고 GCC 4.5를 다운로드하자(참고자료 참조).

GCC에서 아직 지원되지 않는 C++0x 표준의 일부를 간략하게 논의하여 시작해보자.

위로

정적 어설션

정수 크기가 독자가 가정한 4바이트가 아니었기 때문에 이식 가능한(portable) 코드가 고객 사이트에서 파손되었던 때를 기억하는가? C++0x에서 static_assert 구성은 컴파일 시점에 사용 가능하고 다른 플랫폼으로 소스를 마이그레이션해야 할 때 엄청나게 유용한 것을 제외하고, 이러한 종류의 문제를 정확하게 추적하는 데 유용하다. Boost 라이브러리(참고자료 참조)는 지금까지 한동안 정적 어설션에 대한 지원이 있었지만, 언어 핵심(static_assert는 C++0x 키워드임)의 일부로 통합된 정적 어설션을 보유하는 것은 헤더가 더 이상 필요하지 않음을 암시한다(목록 1 참조).

	
// no headers
// using static assertion in global scope
static_assert(sizeof(int) == 4, "Integer sizes expected to be 4");

int main()
{
    return 0;
}

필자의 64비트 엔터프라이즈 Linux® 시스템에서 이 어설션은 컴파일 도중에 실패한다. 로그는 다음과 같다.

g++ 1.cpp --std=c++0x 
1.cpp :1:1: error: static assertion failed: " Integer sizes expected to be 4"

전역 범위 및 네임스페이스, 함수 본문 또는 클래스 선언 내부에 정적 어설션을 사용할 수 있다. 목록 2는 정적 어설션을 사용하는 것이 특정 인수 유형으로 템플리트된 클래스를 인스턴스화하는 것을 방지하는 데 유용한 또 다른 예제를 제시한다. 해당 기술은 클래스의 특수화된 버전에서 실패하도록 바운드된 정적 어설션을 추가하는 것이다. 정적 어설션을 사용하는 동안 항상 선택된 표현식이 컴파일 시점에 평가 가능하게 되어야 함을 유의하자.

	
// using static assertions as part of class declaration 
template <typename T1, typename T2>
class T {
	T1 a;
	T2 b;
};

template <typename T1>
class T<T1, bool> { 
	static_assert(sizeof(T1) == 0, "T<T1, bool> is not allowed, sorry");
};

int main( )
{ 
   T<float, bool> f1; // this will fail compilation 
   T <float, int> i2; // fine
   …
}

위로

새 문자 유형 소개하기

인정하건대, 유니코드에 대한 C/C++ 지원은 항상 존재하지 않았다. 유니코드는 세 가지 서로 다른 크기—UTF-8, UTF-16 및 UTF-32—에서 문자 인코딩을 정의하는 반면, 기존 문자 유형은 8비트이다. wchar_t의 크기가 구현 방식으로 정의되기 때문에 wchar_t를 사용하는 것은 옵션이 아니다.

C++0x는 새로운 두 가지 키워드—char16_t 및 char32_t—를 보장된 크기(각각 16 및 32비트—목록 3 참조)로 소개하며, 이는 부호 없는 유형이다. 비록 표준이 헤더 cuchar를 포함하도록 요청하지만, 이러한 새 유형을 사용하려면 C++ 헤더 cstdint를 포함해야 한다.

	
#include <iostream>
#include <cstdint>  // this is the header for char16_t and char32_t 
using namespace std;

int main()
{
    char16_t c = 'A';
    cout << sizeof(c) << endl;
    char32_t d = 'b';
    cout << sizeof(d) << endl;
    return 0;
}

당연하게도 목록 3으로부터의 출력은 콘솔에서 2 및 4를 인쇄한다. 이제 아래 목록 4와 같이 char32_t 유형의 배열을 정의하는 것을 시도하자.

	
#include <iostream>
#include <cstdintglt;
using namespace std;

int main()
{
    char32_t e[ ] = "Hello World";
    cout << sizeof(e) << endl;
    return 0;
}

해당 컴파일러 로그는 다음과 같다.

g++ 1.cpp --std=c++0x 
1.cpp: In function 'int main()':
1.cpp:7:8: error: int-array initialized from non-wide string

여기에서 문제는 무엇인가? 우선, 초보자를 위해 "Hello World"는 정규 문자당 8비트 문자열이고, 문자당 32비트의 배열로 이를 지정하는 것은 올바르지 않다. 이러한 새 유형에 대해 독자는 해당 유형에 따라 문자열로 u 또는 U를 접두부 처리하여 문자열 리터럴을 작성한다. 목록 5를 살펴보자.

	
#include <iostream>
#include <cstdint>  
using namespace std;

int main()
{
    char16_t f[ ] = u"Hello World";  // prefix the string with u for char16_t
    cout << sizeof(f) << endl;
    char32_t e[ ] = U"Hello World"; // prefix the string with U for char32_t
    cout << sizeof(e) << endl;
    return 0; 
}

예상되는 콘솔 출력은 24와 48이었고, g++가 그 역할을 훌륭하게 수행했다.

위로

새 auto 구문 시작: 초기화 프로그램 표현식에서부터 유형 추론

이는 초기화 프로그램 표현식에서부터 변수에 대한 적절한 유형을 추론하는 컴파일러를 사용하는 것으로 구세주와 같은 것이다. 따라서, class1::class3::struct1::enum2 e와 같은 이전의 모든 선언들은 이제 지나간 일이 되었다. auto 키워드는 C++0x와 완전히 다른 시맨틱이 있다. 목록 6은 첫 번째 예제를 제공한다.

	
#include <iostream>
#include <map>  
using namespace std;

int main()
{
    auto *num1 = new int(7);  // type for num1 is int* 
    const auto num2 = 3.1415;  // type for num2 is double

    // now for some serious business 
    map<int, string> map1;
    map1.insert(make_pair<int, string> (7, "8"));
    auto mapit1 = map1.find(7);  // type for mapit1 is std::map::iterator
    cout << mapit1->second << endl; 
    … // continue coding 
}

num1에 대한 유형은 정수 포인터이다. 반면 num2는 부동이고 mapit1is std::map::iterator이다. 복수 선언들이 auto를 사용하도록 허용되지만, 모든 추론은 동일한 유형으로 이끌어야 한다. 선언은 왼쪽에서 오른쪽으로 진행된다. 아래 목록 7은 auto를 사용하고 작동하지 않는 코드를 보여준다.

	
int main( )
{
   auto i = 9, j = 8.2; // error – i and j should be same type
   auto k = &k; // dumb error – can’t declare and use in initializer
   …
}

여기에 다음 목록 7에 대한 컴파일러 로그가 나와 있다.

1.cpp: In function 'int main()':
1.cpp:3:8: error: inconsistent deduction for 'auto': 'int' and then 'double'
1.cpp:4:8: error: variable 'auto k' with 'auto' type used in its own initializer

auto와 관련하여 다른 미묘한 사항들이 있다. 예를 들어, 이를 스토리지 클래스 지정자로 사용하는 것은 C++0x와 함께 작동하지 않을 것이다. 다음 코드 스니펫은 g++ 명령행에서 –std=c++0x를 제거하는 경우 훌륭하게 작동한다.

auto int variable1 = 8;

여기에 다음 g++ --std=c++0x 로그가 나와 있다.

1.cpp: In function 'int main()':
1.cpp:28:14: error: two or more data types in declaration of 'variable1'

위로

초기화 프로그램 목록 및 유형 축소 변환(type narrowing)

훌륭한 이전 int integer_array1 [ ] = {1, 2, 3, 4, 5};가 기존 C/C++에서부터 구축하는 것을 기억하는가? {}를 사용하여 정의된 해당 목록—이는 초기화 프로그램 목록이다. 이를 제외하고 해당 언어는 이 구축의 더 광범위한 기반의 사용에 시맨틱을 제공하지 않았다. C++0x는 다음과 같이 초기화 프로그램 목록에 대한 추가 사용법 규칙을 정의한다.

• 변수 정의에서 초기화 프로그램 목록.
• 새 표현식에서 초기화 프로그램 목록.
• 함수 인수 및/또는 함수 리턴 명령문으로 사용될 수 있다.
• 첨자 표현식으로 허용된다.
• 생성자 호출로 인수로서 허용된다.
• 유형 축소 변환(type narrowing)은 허용되지 않는다.

초기화 프로그램 목록 예제 및 일반 사용법으로 이동하기 전에 유형 축소 변환(type narrowing)이 의미하는 내용에 대해 살펴보자. 목록 8에서 코드를 고려하자.

	
int main( )
{
   int nasty[ ] = {8, 99, 2.3, 4.0, 5};
   // …     return 0;
}

컴파일러가 g++ –Wall 옵션으로 컴파일할 때에, 매우 지저분한 double에서 integer로 유형 변환이 나타났음에도 불구하고 위의 코드에 대한 어떠한 경고도 내보내지 않았다. 이는 유형 축소 변환(type narrowing)의 예제이며, 감사하게도 C++0x 표준은 독자의 코드에서 이에 대해 허용하지 않는다. 여기에 g++ –std=c++0x로 코드를 컴파일할 때 다음과 같이 로그가 나와 있다.

1.cpp: In function 'int main()':
1.cpp:14:34: error: narrowing conversion of 
    '2.29999999999999982236431605997495353221893310547e+0' 
    from 'double' to 'int' inside { }
1.cpp:14:34: error: narrowing conversion of '4.0e+0' 
    from 'double' to 'int' inside { }

더 긍정적인 면을 살펴보자. 목록 9에서 선언이 이제 허용된다.

	
// Initializer list used with variable definition
std::vector<double> doubles = {2.3, 4.511, 1.23, 0.99};

// Initializer list used with new 
std::list<double> *d2 = new std::list<double> {1.2, 1.3}; 

// Initialize a map 
std::map<string, int> = { {“key1”, 1}, {“key2”, 2} };

스칼라 변수를 초기화하기 위해 초기화 프로그램을 사용하는 것은 문제가 없으며, 유형 축소 변환(type narrowing)의 일반적인 규칙은 이러한 경우에 적용된다. 변수가 빈 초기화 프로그램 목록으로 초기화되면 오브젝트는 값이 초기화된다. 목록 10의 출력은 2 0 a A both x3 and x4 are null이다.

	
int main( )
{
    int x{2};
    double x2{};
    char* x3{};
    int* x4 = {};
    char c1 = {‘a’} ;
    char c2 = char{‘A’} ;
    cout << x << " " << x2 << " "  
        << c1 << " " << c2 << endl;
    if (x3 == NULL && x4 == NULL)
        cout << "both x3 and x4 are null\n";
    // int y{2.3}; → don’t try this error due to type narrowing 
    return 0;
}

int y(2.3)가 C++0x에서 허용되었고, 유형 축소 변환(type narrowing)이 없는 것으로 가정하며, y가 2와 같은 반면에 int y{2.3}은 일반 오류이다. 이러한 종류의 시맨틱을 고려하면, 초기화 프로그램 목록을 사용하는 것은 가능한 언제나 선호되어야 한다. C++0x 표준은 함수와 생성자로 인수를 전달하는 데 사용할 수 있는 initializer_list라는 새 클래스 유형(적절하게)을 정의한다. 또한, 함수 리턴 명령문은 initializer_list를 리턴하도록 허용한다. 하지만, 이 클래스 유형을 사용하기 위해 헤더 initializer_list를 포함해야 한다. 목록 11은 initializer_list의 샘플 사용을 제공한다.

	
#include <initializer_list> 

// argument to function
void func1(std::initializer_list<int>);

// function returning initializer list
std::initializer_list<double> func2 (double);

목록 12는 초기화 프로그램 목록을 횡단하는 방법을 보여준다. 해당 함수가 불변 순서로 목록에 액세스할 수만 있음을 확인하자. —다시 말해서, 목록의 컨텐츠를 수정하려고 시도하면 오류가 발생한다.

	
#include <initializer_list> 
using namespace std; 
void display (initializer_list<int> arguments) {
    for (auto p= arguments.begin(); p!= arguments.end(); ++p) {
	    // *p = *p * 2; → Not allowed to modify data 
	    cout << *p << "\n";
    }
}

int main( )
{
    display( {3, 77, 8, 1, 9} );
    return 0;
}

위로

초기화 프로그램 목록으로 auto 사용하기

목록 13 코드에서 x1에 대한 유형은 무엇인가?

	
int main( )
{
    auto x1 = {2, 4};
    auto z2 = {3, 2.3} ; // go figure
    ...
    return 0 ;
}

독자가 아직 이를 추측하지 않았다면, x1에 대한 유형은 std::initializer_list<int>이다. z2의 경우 g++에서 오류를 발생하여, 유형 축소 변환(type narrowing)에 매우 올바르게 항의한다. 독자가 x1에 대한 유형을 여전히 불신한다면, 목록 14에서 입력해보자.

	
#include <iostream>
#include <initializer_list>
using namespace std;

template <typename T>
void display() {}

template <>
void display<std::initializer_list<int>> () { cout << "Hurray!\n"; }

int main()
{
   auto x = {2, 3};
   display<decltype(x)> ();
   return 0;
}

목록 14에서부터 출력은 Hurray!이다. display에 대한 템플리트 특수화로 인해 x1의 주장하는 유형에 대해 논쟁이 나타난다. 이는 또한 또 다른 C++0x 구성인 decltype으로 이끈다.

위로

decltype 이해하기

C++는 변수 또는 표현식의 유형을 쿼리하기 위한 간편한 메커니즘이 없었다. GCC는 typeof(참고자료 참조)라는 확장을 제공하지만, 이는 표준은 아니다. C++0x에서부터 decltype 연산자를 입력한다. 이는 변수 또는 표현식의 유형을 리턴한다. 템플리트 프로그래밍을 좋아하는 독자라면, 아마도 이로 인해 즉시 C++0x 변환을 해야 하게 될 것이다. 목록 15는 변수에 decltype 연산자를 적용하고 표현식으로 연산자의 사용법을 보여준다.

	
T1 x; 
T2 y;
typedef T3 decltype(x+y); 
T3 z ; 

위로

람다 함수

C++0x 표준의 특정한 새 기능과 연관된 선전에 대한 상이 있다면, 람다 함수가 최우수상을 받을 것이다. 람다 함수는 익명 함수이며, 해당 역할을 수행하기 위해 일반적인 C/C++ 함수를 정의할 필요가 없음을 의미한다. 아마 람다의 가장 일반적인 사용은 STL sort를 사용하는 것이다. 지금까지, 사용자 정의 비교 함수를 사용하기 위해 표준 사용은 자체적인 함수 오브젝트를 정의하는 것이었고, 그 다음에 연산자 ( )를 적절하게 정의하는 것이었다. 다섯 가지 문자열의 벡터를 고려하자. 독자는 이를 늘어나는 문자열 길이 단위로 정렬하려고 한다. 목록 16은 기존 접근방식을 보여준다.

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

struct compare {
    bool operator()(const string& s1, const string& s2) { 
        return s1.size() < s2.size();
    }
};

int main()
{
    vector<string> vs = {"This", "is", "a", "C++0x", "exercise"};
    std::sort(vs.begin(), vs.end(), compare());

    for (auto ivs = vs.begin(); ivs != vs.end(); ++ivs)
        cout << *ivs << endl;
    return 0;
}

목록 17은 새 람다 기반 접근방식을 보여준다.

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

int main()
{
    vector<string> vs = {"This", "is", "a", "C++0x", "exercise"};
    std::sort(vs.begin(), vs.end(), 
       [ ](const string& s1, const string& s2) { 
          return s1.size() < s2.size(); 
       } 
    )

    for (auto ivs = vs.begin(); ivs != vs.end(); ++ivs)
        cout << *ivs << endl;
    return 0;
}

두 프로그램(목록 16 및 목록 17)에서부터의 출력은 a is This C++0x exercise이다. 목록 18을 간략하게 살펴보면 람다 함수가 어떻게 정의되는지 알려준다. 이는 [ ]라는 부분을 제외하고 정규 함수를 정의하는 것과 거의 동일한 것처럼 보인다. 그렇지 않은가? 자, 이는 맞는 말인 동시에 틀린 말이다. 답변으로 나눌 수 있기 전에 다음과 같은 질문을 해야 한다.

• 람다 함수의 리턴 유형에 무엇이든지 발생했는가?
• 이러한 함수가 범위의 바깥에서 정의된 변수에 액세스할 수 있는가? 예를 들어, 목록 17에서 람다 함수가 vs에 액세스할 수 있는가?

답변에 대해 계속 진행한다. 람다 함수의 리턴 유형을 제공할 필요는 없다. 이는 리턴 명령문에서부터 추론된다. 목록 17에서 람다 함수의 리턴 유형은 부울이다. 두 번째 질문에 대해 목록 18에 제시된 어색한 코드를 시도해보기만 하자.

	
int main()
{
    vector<string> vs = {"This", "is", "a", "C++0x", "exercise"};
    std::sort(vs.begin(), vs.end(), 
       [ ](const string& s1, const string& s2) { 
          cout << vs.size( ) << endl;
          return s1.size() < s2.size(); 
       } 
    )
   …
}

따라서, sort가 람다를 호출할 때마다 벡터의 크기를 인쇄하려고 시도하는 중이다. 여기에 컴파일 도중에 g++가 보고한 내용이 다음과 같이 나와 있다.

1.cpp: In lambda function:
1.cpp:12:9: error: 'vs' is not captured

이 문제를 "수정"하는 두 가지 방법이 있다—사실은 네 가지 방법이다. 람다 함수로 인수를 전달하기 위해 이전에 봤던 꺾쇠괄호([])를 사용할 수 있다. 변수를 참조로 전달하도록 선택하면, &로 접두부 처리하며, [ ] 내부에 이를 넣는다. 값으로 전달하는 변수의 경우 이를 등호 부호(=)로 접두부 처리한다. 목록 19는 참조로 전달된 vs가 있다.

	
int main()
{
    vector<string> vs = {"This", "is", "a", "C++0x", "exercise"};
    std::sort(vs.begin(), vs.end(), 
       [ &vs ](const string& s1, const string& s2) { 
          cout << vs.size( ) << endl;
          return s1.size() < s2.size(); 
       } 
    )
   …
}

이번에 컴파일러가 훌륭하게 컴파일했다. (분명히 하기 위해 이 코드를 [ =vs ]로 시도하자.) 따라서, 벡터를 람다로 전달하는 세 번째 방법은 무엇인가? 자, [ & ]만 사용하자. 이 구문은 모든 로컬 변수가 람다 함수로 참조로 전달될 것임을 암시한다. 기술적으로 말해서, [ = ]도 사용하여 모든 로컬 변수를 값으로 함수로 전달할 수도 있다. 즉, 이는 네 번째 수행 방법이다. 하지만, 성능 상의 이유로 이 접근방식은 권장되지 않는다.

위로

가변인자(variadic) 템플리트

각각 잠재적으로 다른 유형으로 인수의 변동 가능한 숫자로 템플리트된 클래스 또는 함수를 어떻게 정의하는가? C는 va_list를 사용하여 인수의 변수 숫자로 함수를 정의하는 것에 대한 지원이 있으며, C++는 이에 대해 절대 개선되지 않았다. 지금까지는 그렇다. C++0x를 통해 독자는 인수의 변수 숫자로 함수와 클래스를 정의할 수 있으며, 지원은 이제 GCC에서도 동일하다. 목록 20은 해당 구문을 보여준다.

	
template<typename... Types> 
void f(Types... args) // variable number of function arguments 
{
}

template<typename... Types> 
class c // class with 
{
   // member code 
};

// Usages
f(‘a’, “hello”, 2, 3.1); 
class c<int, double, std::vector<string>> c1;

가변 인자 템플리트를 선언하기 위해 typename…을 사용한다. C++0x도 sizeof… 연산자를 정의하며, 이는 인수의 숫자를 표시한다. 불행히도, 인수에 대해 반복할 수 있는 직접적인 방법이 없다. 템플리트 탐색에 대한 유일한 진행 방법은 기본 케이스와 함께 동일한 순환적인 버전을 정의하는 것이다. 이는 최상의 방법은 아니지만, 지금까지의 내용이 진행되는 방법이다. 목록 21은 가변 인자 함수 템플리트의 인수를 어떻게 인쇄할 수 있는지 보여준다.

	
void f() { }

template<typename T, typename... Types> 
void f(T a, Types... args)
{
    cout << sizeof...(args) << endl;
    cout << a << endl;
    f(args...);
}

int main()
{
   f("hello", 'a', 8.333);
   return 0;
}

여기에 목록 21에서 나타나는 내용에 대해 하나 하나 차례대로 설명이 나와 있다.

1. 첫 번째로 f의 템플리트된 버전이 첫 번째 인수 유형으로 문자열과 함께 호출되고, 문자와 두 배가 변수 크기 인수로 보내진다.
2. 첫 번째 호출에서, sizeof…(args)는 2를 표시한다. 왜냐하면 변수 args 목록에 대해 두 가지 인수만 있기 때문이다.
3. 구문 args…를 관찰하자. …는 이제 args의 오른쪽에 있다. f로 두 번째 호출은 8.333만 포함하는 변수 목록을 보유할 것이며, 한편 a는 첫 번째 인수가 된다.
4. 인수를 다 쓰면, g++는 void f() { }를 호출하여 종료하며, 이는 순환에 대한 기본 케이스이다.

여기에 다음과 같이 목록 21의 출력이 나와 있다.

2
hello
1
a
0
8.333

위로

다가올 사항의 상태

GCC의 향후 버전은 더 흥미로운 내용이 될 것을 약속한다. 일부 기능들이 다음을 포함하도록 예상된다.

• 가비지 콜렉션 ABI(application binary interface) 지원. C++0x 표준은 애플리케이션 개발자들이 가비지 콜렉션을 수정하도록 허용하는 애플리케이션 개발자들에 액세스 가능한 인터페이스를 정의한다. 예를 들어, 사전 정의된 함수인 void declare_reachable(void* p);은 가비지 콜렉터에게 포인터 p가 가리키는 스토리지를 재확보하지 않도록 요청한다.
• 동시성에 대한 더 우수한 지원. C++0x 스레드에 대한 GCC 지원은 모든 플랫폼에 원활히 작동하지 않는다(예를 들어, Cygwin). 스레드 특화된 스토리지도 작업이 진행 중이다.

위로

결론

지금은 C++(또는 C++0x라고 해야 하는가?) 개발자가 되는 것이 흥미로운 시점이다. 표준 커미티는 템플리트 프로그래밍, 늘어난 유형 보안, 시스템 소프트웨어 및 라이브러리 개발을 위해(Stroustrup의 언어에서부터 차용하는 용도 [참고자료 참조]) 더 나은 플랫폼으로 C++를 모핑하는 기능을 추가하고 있다. 이 기사는 GCC 버전 4.5에서 현재 지원되는 언어의 몇 가지 기능에 대한 간단한 개요를 제공했다. 추가 세부사항은 GCC 사이트와 참고자료 섹션을 참조하자.

참고자료

교육

• C++0x FAQ: Stroustrup이 유지보수하는 C++0x FAQ 사이트를 방문하자.
  
  
• C++0x 컴파일러 지원: C++0x 컴파일러 지원의 이러한 비교 연구를 통해 자세히 학습하자.
  
  
• C++0x 초안 표준: C++0x 표준의 초안 사본을 읽어보자.
  
  
• C++ 논문: C++ 표준 커미티 논문을 읽어보자.
  
  
• GCC: GCC 홈 페이지를 방문하자.
  
  
• typeof: GCC typeof 연산자에 대해 자세히 학습하자.
  
  
• Delegating constructors: 구성 위임에 대한 백서를 읽어보자.
  
  
• AIX와 UNIX developerWorks 영역: AIX와 UNIX 영역에서는 AIX 시스템 관리와 UNIX 스킬 확장의 모든 측면과 관련된 풍부한 정보를 제공한다.
  
  
• AIX와 UNIX 입문 AIX와 UNIX 입문 페이지에서 자세한 정보를 볼 수 있다.
  
  
• 기술 서점: 다양한 기술 주제와 관련된 서적을 살펴볼 수 있다.
  
  

제품 및 기술 얻기

• GCC binaries: 설치를 위해 GCC 2진을 다운로드하자.
  
  
• Boost 라이브러리: Boost C++ 라이브러리에 대해 자세히 배우고 다운로드하자.
  
  

토론

• Twitter의 developerWorks 페이지를 살펴보자.
  
  
• My developerWorks 커뮤니티에 참여하자.
  
  
• AIX 및 UNIX® 포럼에 참여하자.
  • AIX Forum
  • AIX Forum for developers
  • Cluster Systems Management
  • Performance Tools Forum
  • PowerVM Forum
  • 기타 AIX and UNIX Forums
  
  

필자소개

아티클 순위

의견

위로

목차

• 소개
• 정적 어설션
• 새 문자 유형 소개하기
• 새 auto 구문 시작: 초기화 프로그램 표현식에서부터 유형 추론
• 초기화 프로그램 목록 및 유형 축소 변환(type narrowing)
• 초기화 프로그램 목록으로 auto 사용하기
• decltype 이해하기
• 람다 함수
• 가변인자(variadic) 템플리트
• 다가올 사항의 상태
• 결론
• 참고자료
• 필자소개
• 의견