all2one awakening

명시적 변환 연산자explicit conversion operators
C++98에서는 혼란을 유발하는 암묵적 변환을 방지하지 위해 다음과 같이 변환 생성자에 명시적이어야 함을 지정할 수 있었습니다.
struct S { S(int); }; // "평범한 생성자"는 암묵적 변환을 의미 S s1(1); // ok S s2 = 1; // ok void f(S); f(1); // ok (하지만 원치 않는 동작일 경우가 많죠 -- 가령 S가 vector였다면?) struct E { explicit E(int); }; // 명시적 생성자 E e1(1); // ok E e2 = 1; // 오류 (이놈도 위와 똑같은 생성 구문이기에) void f(E); f(1); // 오류 (실수가 새나가는 것을 방지 -- 예를 들어, int를 인자로 받는 std::vector의 생성자는 명시적)
하지만 가능한 변환을 정의하는 방법은 이것 말고 하나가 더 있죠. 해당 클래스를 수정할 수 없는 경우, 상대편 클래스에 변환 연산자를 정의해주는 것이 그것입니다.
struct S { S(int) { } /* ... */ }; struct SS { int m; SS(int x) :m(x) { } operator S() { return S(m); } // S에 S(SS) 생성자를 두는 대신 SS에 변환 연산자를 둡니다 }; SS ss(1); S s1 = ss; // ok; 암묵적 생성자가 있는 것과 마찬가지 S s2(ss); // ok; 암묵적 생성자가 있는 것과 마찬가지 void f(S); f(ss); // ok; 암묵적 생성자가 있는 것과 마찬가지
이 경우 이전에는 명시성 지정이 불가능했는데 C++0x에서 다음과 같이 가능해졌습니다.
struct S { S(int) { } }; struct SS { int m; SS(int x) :m(x) { } explicit operator S() { return S(m); } // S에 S(SS) 생성자를 두는 대신 SS에 변환 연산자를 둡니다 }; SS ss(1); S s1 = ss; // 오류; explicit 생성자의 경우와 마찬가지 S s2(ss); // ok ; explicit 생성자의 경우와 마찬가지 void f(S); f(ss); // 오류; explicit 생성자의 경우와 마찬가지

범위 for 구문range for statement
begin()과 end() 함수로 규정되는 범위에 대한 반복을 간편한 문법으로 제공하는 기능입니다.
void f(const vector<double>& v) { for (auto x : v) cout << x << '\n'; for (auto& x : v) ++x; // 참조를 사용하면 값을 수정할 수도 있습니다 } for (const auto x : { 1,2,3,5,8,13,21,34 }) cout << x << '\n';

반환형 접미 구문suffix return type syntax
다음과 같은 함수 템플릿이 있습니다.
template<class T, class U> ??? mul(T x, U y) { return x*y; }
이 경우 반환형이 무엇일까요? 물론, x*y의 타입입니다만, 그를 어떻게 나타내느냐는 것이죠. C++0x의 decltype을 사용할 수 있습니다.
template<class T, class U> decltype(x*y) mul(T x, U y) // 스코프 문제! { return x*y; }
하지만 그 시점에 x, y가 스코프에 없기 때문에 오류입니다. 다음과 같이 하면 됩니다.
template<class T, class U> decltype(*(T*)(0)**(U*)(0)) mul(T x, U y) // 보기 어렵고 실수하기 쉬움 { return x*y; }
하지만 역시 만족스럽지 않습니다. 그래서 나온 해법이 반환형을 인자 다음에 선언할 수 있게 하는 겁니다.
template<class T, class U> [] mul(T x, U y) -> decltype(x*y) { return x*y; }
[]는 람다에서 도입된 것으로 "반환형이 유도될 수 있거나 나중에 지정될 것임"을 나타냅니다. 이와 같이 함수가 리턴문으로만 구성된 경우에는 다음과 같이 decltype도 생략할 수 있습니다.
template<class T, class U> [] mul(T x, U y) { return x*y; }

클래스 내 멤버 초기화in-class member initializers
C++98에서는 정수형의 static const 멤버에 대해서만 클래스 내 초기화가 가능했습니다.
int var = 7; class X { static const int m1 = 7; // ok const int m2 = 7; // 오류: static 아님 static int m3 = 7; // 오류: const 아님 static const int m4 = var; // 오류: var가 상수 표현식 아님 static const string m5 = "odd"; // 오류: 정수형 아님 // ... };
C++0x에서는 비정적 데이터 멤버를 선언 시에 초기화할 수 있습니다. 이는 생성자가 많은 다음과 같은 경우에 아주 유용합니다.
class A { public: A(): a(7), b(5), hash_algorithm("MD5"), s("Constructor run") {} A(int a_val) : a(a_val), b(5), hash_algorithm("MD5"), s("Constructor run") {} A(D d) : a(7), b(g(d)), hash_algorithm("MD5"), s("Constructor run") {} int a, b; private: HashingFunction hash_algorithm; // 모두 인스턴스에 적용되는 암호화 해시 std::string s; // 개체 생명주기에서의 한 상태를 나타내는 문자열 };
hash_algorithm과 s 변수가 하나의 초기값만을 가짐에도 각 생성자마다 작업을 되풀이해야 합니다. 유지보수에 쥐약이죠. 이를 다음과 같이 할 수 있습니다.
class A { public: A(): a(7), b(5) {} A(int a_val) : a(a_val), b(5) {} A(D d) : a(7), b(g(d)) {} int a, b; private: HashingFunction hash_algorithm{"MD5"}; // 모두 인스턴스에 적용되는 암호화 해시 std::string s{"Constructor run"}; // 개체 생명주기에서의 한 상태를 나타내는 문자열 };
생성자 초기화 목록이 클래스 내 선언 시점 초기화보다 우선한다는 점을 이용하면, 다음처럼 더 간단히 할 수도 있습니다.
class A { public: A() {} A(int a_val) : a(a_val) {} A(D d) : b(g(d)) {} int a = 7; int b = 5; private: HashingFunction hash_algorithm{"MD5"}; // Cryptographic hash to be applied to all A instances std::string s{"Constructor run"}; // String indicating state in object lifecycle };

목록 초기화initializer lists
다음과 같은 것들이 가능합니다.
vector<double> v = { 1, 2, 3.456, 99.99 }; list<pair<string,string>> languages = { {"Nygaard","Simula"}, {"Richards","BCPL"}, {"Ritchie","C"} }; map<vector<string>,vector<int>> years = { { {"Maurice","Vincent", "Wilkes"},{1913, 1945, 1951, 1967, 2000} }, { {"Martin", "Ritchards"} {1982, 2003, 2007} }, { {"David", "John", "Wheeler"}, {1927, 1947, 1951, 2004} } };
목록 초기화가 더 이상 배열에만 국한되지 않는 것이죠. {}-목록을 받아들이는 것은 std::initializer_list<T> 타입의 인자를 가지는 함수들(보통 생성자)입니다. 가령,
void f(initializer_list<int>); f({1,2}); f({23,345,4567,56789}); f({}); // 빈 목록 f{1,2}; // 오류: 함수 호출 괄호가 없음 years.insert({{"Bjarne","Stroustrup"},{1950, 1975, 1985}});
컨테이너는 다음과 같이 "목록 초기화 생성자"를 제공할 수 있습니다.
template<class E> class vector { public: vector (std::initializer_list<E> s) // 목록 초기화 생성자 { reserve(s.size()); // 딱 필요한 만큼의 자리 확보 uninitialized_copy(s.begin(), s.end(), elem); // 목록에 있는 것들로 원소 초기화 sz = s.size(); // 크기 설정 } // ... as before ... };
표준 라이브러리의 컨테이너들은 이제 목록 초기화 생성자를 지원하고, 범위 for 구문에 나온 것처럼 이러한 초기화 목록은 범위(range)로도 활용 가능합니다.

이번 회는 여기까지입니다. 다음 회면 대충 마무리될듯. ^^

* 이 포스트는 blogkorea [블코채널 : 웹, 컴퓨터, it에 관련된 유용한 정보 및 소식] 에 링크 되어있습니다.  

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.