1
\$\begingroup\$

This is a follow-up question for std::array and std::vector Type Arbitrary Nested Iterable Generator Functions Implementation in C++ and the previous questions about recursive functions, including A Summation Function For Arbitrary Nested Vector Implementation In C++, A recursive_count_if Function For Various Type Arbitrary Nested Iterable Implementation in C++, A recursive_count_if Function with Specified value_type for Various Type Arbitrary Nested Iterable Implementation in C++, A recursive_count_if Function with Automatic Type Deducing from Lambda for Various Type Arbitrary Nested Iterable Implementation in C++ and A recursive_count_if Function with Unwrap Level for Various Type Arbitrary Nested Iterable Implementation in C++. Besides the std::array and std::vector cases, I am trying to implement other functions n_dim_deque_generator and n_dim_list_generator which purpose are similar as n_dim_array_generator and n_dim_vector_generator. In other words, n_dim_deque_generator function can construct nested std::deques with the given parameters and n_dim_list_generator function can construct nested std::lists with the given parameters.

The usage description

As similar to the usage of n_dim_vector_generator, there are four key parts in the usage n_dim_deque_generator<2, int>(1, 3). The first number 2 represents the nested layers, the second parameter int represents the type of base elements, the third parameter 1 represents the input element which would be filled in, and the fourth parameter 3 represents the element count in each layer.

The experimental implementation

The experimental implementation of n_dim_deque_generator function and n_dim_list_generator function:

template<std::size_t dim, class T>
auto n_dim_deque_generator(T input, std::size_t times)
{
    if constexpr (dim == 0)
    {
        return input;
    }
    else
    {
        std::deque<decltype(n_dim_deque_generator<dim - 1>(input, times))> output;
        output.resize(times);
        std::fill(std::begin(output), std::end(output), n_dim_deque_generator<dim - 1>(input, times));
        return output;
    }
}

template<std::size_t dim, class T>
auto n_dim_list_generator(T input, std::size_t times)
{
    if constexpr (dim == 0)
    {
        return input;
    }
    else
    {
        std::list<decltype(n_dim_list_generator<dim - 1>(input, times))> output;
        output.resize(times);
        std::fill(std::begin(output), std::end(output), n_dim_list_generator<dim - 1>(input, times));
        return output;
    }
}

Test cases

The test cases of n_dim_deque_generator function and n_dim_list_generator function are as below. The test cases of n_dim_vector_generator function and n_dim_array_generator function are also listed, for comparison purposes.

constexpr std::size_t dims_setting = 8;
int input_element = 3;
constexpr std::size_t element_count = 2;

//  n_dim_vector_generator function usage with recursive_reduce function and recursive_count_if function
auto test_vector1 = n_dim_vector_generator<dims_setting, int>(input_element, element_count);
std::cout << "recursive_reduce output: " << recursive_reduce(test_vector1, 0) << std::endl;
std::cout << "recursive_count_if output: " << recursive_count_if<dims_setting>(test_vector1, [](auto& i) {return i == 3; }) << std::endl;

//  n_dim_array_generator function usage with recursive_reduce function and recursive_count_if function
auto test_array1 = n_dim_array_generator<dims_setting, element_count, int>(input_element);
std::cout << "recursive_reduce output: " << recursive_reduce(test_array1, 0) << std::endl;
std::cout << "recursive_count_if output: " << recursive_count_if<dims_setting>(test_array1, [](auto& i) {return i == 3; }) << std::endl;

//  n_dim_deque_generator function usage with recursive_reduce function and recursive_count_if function
auto test_deque1 = n_dim_deque_generator<dims_setting, int>(input_element, element_count);
std::cout << "recursive_reduce output: " << recursive_reduce(test_deque1, 0) << std::endl;
std::cout << "recursive_count_if output: " << recursive_count_if<dims_setting>(test_deque1, [](auto& i) {return i == 3; }) << std::endl;

//  n_dim_list_generator function usage with recursive_reduce function and recursive_count_if function
auto test_list1 = n_dim_list_generator<dims_setting, int>(input_element, element_count);
std::cout << "recursive_reduce output: " << recursive_reduce(test_list1, 0) << std::endl;
std::cout << "recursive_count_if output: " << recursive_count_if<dims_setting>(test_list1, [](auto& i) {return i == 3; }) << std::endl;

The output of this test is as follows.

recursive_reduce output: 768
recursive_count_if output: 256
recursive_reduce output: 768
recursive_count_if output: 256
recursive_reduce output: 768
recursive_count_if output: 256
recursive_reduce output: 768
recursive_count_if output: 256

Notes

The n_dim_vector_generator function and n_dim_array_generator function have been updated as follows. Thanks to G. Sliepen for answering the previous question.

template<std::size_t dim, class T>
auto n_dim_vector_generator(T input, std::size_t times)
{
    if constexpr (dim == 0)
    {
        return input;
    }
    else
    {
        std::vector<decltype(n_dim_vector_generator<dim - 1>(input, times))> output;
        output.reserve(times);
        std::fill_n(std::back_inserter(output), times, n_dim_vector_generator<dim - 1>(input, times));
        return output;
    }
}

template<std::size_t dim, std::size_t times, class T>
auto n_dim_array_generator(T input)
{
    if constexpr (dim == 0)
    {
        return input;
    }
    else
    {
        std::array<decltype(n_dim_array_generator<dim - 1, times>(input)), times> output;
        std::fill(std::begin(output), std::end(output), n_dim_array_generator<dim - 1, times>(input));
        return output;
    }
}

A Godbolt link is here.

All suggestions are welcome.

The summary information:

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Browse other questions tagged or ask your own question.