C++
std :: integer_sequence
수색…
소개
클래스 템플릿
std::integer_sequence<Type, Values...>
는 Type
의 값 시퀀스를 나타냅니다. 여기서 Type
은 기본 제공 정수 유형 중 하나입니다. 이러한 순서는 위치 액세스의 이점을 가지는 클래스 또는 함수 템플리트를 구현할 때 사용됩니다. 표준 라이브러리에는 요소 수에서 오름차순으로 정수 값 시퀀스를 만드는 "팩토리"유형도 포함되어 있습니다.
std :: tuple을 돌린다. 기능 매개 변수로
std::tuple<T...>
는 여러 값을 전달하는 데 사용될 수 있습니다. 예를 들어, 일련의 매개 변수를 대기열의 일부 양식에 저장하는 데 사용할 수 있습니다. 이러한 튜플을 처리 할 때 요소를 함수 호출 인수로 변환해야합니다.
#include <array>
#include <iostream>
#include <string>
#include <tuple>
#include <utility>
// ----------------------------------------------------------------------------
// Example functions to be called:
void f(int i, std::string const& s) {
std::cout << "f(" << i << ", " << s << ")\n";
}
void f(int i, double d, std::string const& s) {
std::cout << "f(" << i << ", " << d << ", " << s << ")\n";
}
void f(char c, int i, double d, std::string const& s) {
std::cout << "f(" << c << ", " << i << ", " << d << ", " << s << ")\n";
}
void f(int i, int j, int k) {
std::cout << "f(" << i << ", " << j << ", " << k << ")\n";
}
// ----------------------------------------------------------------------------
// The actual function expanding the tuple:
template <typename Tuple, std::size_t... I>
void process(Tuple const& tuple, std::index_sequence<I...>) {
f(std::get<I>(tuple)...);
}
// The interface to call. Sadly, it needs to dispatch to another function
// to deduce the sequence of indices created from std::make_index_sequence<N>
template <typename Tuple>
void process(Tuple const& tuple) {
process(tuple, std::make_index_sequence<std::tuple_size<Tuple>::value>());
}
// ----------------------------------------------------------------------------
int main() {
process(std::make_tuple(1, 3.14, std::string("foo")));
process(std::make_tuple('a', 2, 2.71, std::string("bar")));
process(std::make_pair(3, std::string("pair")));
process(std::array<int, 3>{ 1, 2, 3 });
}
클래스가 std::get<I>(object)
및 std::tuple_size<T>::value
하는 한 그것은 위의 process()
함수로 확장 될 수 있습니다. 함수 자체는 인수의 수와 완전히 독립적입니다.
정수로 구성된 매개 변수 팩 만들기
std::integer_sequence
자체는 매개 변수 팩으로 변환 될 수있는 정수 시퀀스를 보유하는 것입니다. 주요한 가치는 이러한 시퀀스를 생성하는 "팩토리"클래스 템플릿을 생성 할 수 있다는 것입니다.
#include <iostream>
#include <initializer_list>
#include <utility>
template <typename T, T... I>
void print_sequence(std::integer_sequence<T, I...>) {
std::initializer_list<bool>{ bool(std::cout << I << ' ')... };
std::cout << '\n';
}
template <int Offset, typename T, T... I>
void print_offset_sequence(std::integer_sequence<T, I...>) {
print_sequence(std::integer_sequence<T, T(I + Offset)...>());
}
int main() {
// explicitly specify sequences:
print_sequence(std::integer_sequence<int, 1, 2, 3>());
print_sequence(std::integer_sequence<char, 'f', 'o', 'o'>());
// generate sequences:
print_sequence(std::make_index_sequence<10>());
print_sequence(std::make_integer_sequence<short, 10>());
print_offset_sequence<'A'>(std::make_integer_sequence<char, 26>());
}
print_sequence()
함수 템플릿은 정수 순서를 확장 할 때 std::initializer_list<bool>
사용하여 평가 순서를 보장하고 사용되지 않는 [배열] 변수를 생성하지 않습니다.
일련의 색인을 요소의 사본으로 변환
값으로 쉼표 표현식에서 인덱스의 매개 변수 팩을 확장하면 각 인덱스에 대한 값의 복사본이 만들어집니다. 안타깝게도 gcc
와 clang
은 인덱스가 효과가 없다고 생각하고 경고합니다 ( gcc
는 인덱스를 void
로 캐스팅하여 음소거 할 수 있음).
#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <string>
#include <utility>
template <typename T, std::size_t... I>
std::array<T, sizeof...(I)> make_array(T const& value, std::index_sequence<I...>) {
return std::array<T, sizeof...(I)>{ (I, value)... };
}
template <int N, typename T>
std::array<T, N> make_array(T const& value) {
return make_array(value, std::make_index_sequence<N>());
}
int main() {
auto array = make_array<20>(std::string("value"));
std::copy(array.begin(), array.end(),
std::ostream_iterator<std::string>(std::cout, " "));
std::cout << "\n";
}
Modified text is an extract of the original Stack Overflow Documentation
아래 라이선스 CC BY-SA 3.0
와 제휴하지 않음 Stack Overflow