When programming, loops, and iteration are often required by developers. Occasionally, looping through a range of numbers whose span is unknown becomes necessary std::integer sequence is useful in that scenario.
By using std::integer_sequence provided by C++14, one can create a sequence of integers at the compile time. The program knows the sequence of integers before it runs. With this tool, one can engage in template programming, and meta-programming, and make coding less complex.
The parameter pack Ints which represents the sequence of elements can be deduced and used in pack expansion when std::integer_sequence is used as an argument to a function template.
Syntax
template <typename T, T... Ints> struct integer_sequence;
Where struct is used to define an integer sequence with the given values in Ints.
Template Parameters
- T: It is the type of the integers.
- Ints: It is a parameter pack of integers.
Member functions
- size(): It returns the number of elements in the sequence of elements represented by parameter pack Ints.
Examples of std::integer_sequence
Example 1:
In the below code, we will make use of the above syntax to demonstrate the use of the std::integer_sequence in C++ 14.
#include <iostream>
#include <utility>
using namespace std;
template <typename T, T... Is>
void print_sequence(integer_sequence<T, Is...>)
{
cout << "The sequence is: ";
((cout << Is << ' '),
...); // fold expression to print sequence
}
int main()
{
print_sequence(integer_sequence<int, 1, 2, 3, 4>{});
return 0;
}
Output
The sequence is: 1 2 3 4
Explanation:
In this code, A std::integer sequence parameter is passed to the print_sequence function, which is defined in this code. The function then prints its values. Printing the sequence on a single line separated by spaces is done by utilizing a fold expression.
Example 2:
In the below code, the integer_sequence_size struct uses template specialization to recursively calculate the size of the integer_sequence.
#include <iostream>
#include <utility>
using namespace std;
// Struct to calculate the size of an integer_sequence
template <typename T, T... Ints>
struct integer_sequence_size;
// Partial specialization for an integer_sequence with at
// least one element
template <typename T, T Head, T... Tail>
struct integer_sequence_size<T, Head, Tail...> {
static constexpr size_t value
= 1 + integer_sequence_size<T, Tail...>::value;
};
// Specialization for an empty integer_sequence
template <typename T> struct integer_sequence_size<T> {
static constexpr size_t value = 0;
};
int main()
{
// Define an integer_sequence
using my_sequence
= integer_sequence<int, 0, 1, 2, 3, 4>;
// Print the size of the integer_sequence using the
// custom struct
std::cout
<< "Size: "
<< integer_sequence_size<int, 0, 1, 2, 3, 4>::value
<< endl;
// Output: Size: 5
return 0;
}
Output
Size: 5
Advantages of using std::integer_sequence in C++ 14 are:
- Simplifies template metaprogramming: By presenting a straightforward approach for producing compile-time sequences of integers, std::integer sequence streamlines template metaprogramming in C++14. It reduces the necessity of tangled and inaccurate recursive template functions.
- Improves readability: By using std::integer sequence, you can write more simple code, since it removes the requirement for complicated template function calls.
- Enables pack expansion: Std::integer sequence enables the creation of efficient code by allowing for the expansion of parameter packs. Furthermore, it has the capability to process numerous template arguments.
