C++ function template implementation to find the min/max value from three vectors

The interface (using an enum to select between two implementations) is a bit unconventional, given that the standard library has std:minmax() and that this family of standard algorithms all accept a comparator function. And the dependence on std::uint8_t existing. But neither of those are your fault.

We're missing a couple of headers whose declarations we use: <algorithm> and <vector>.

Instead of duplicating the code for min and max, perhaps we should use common code, but choose between std::less<T> and std::greater<T> according to the value of M?

When we have the min/max value from each vector, we should apply std::ranges::max/std::ranges::min to that set of values, rather than hand-crafting the greatest-of three.

Talking of ranges, the views library allows us create a concatenation of all three arrays and treat them as a single range:

#include <algorithm>
#include <ranges>
#include <vector>

enum class minmax_t : std::uint8_t { MIN, MAX };

template <minmax_t M, typename T>
constexpr T get(const std::vector<T> &v1,
                const std::vector<T> &v2,
                const std::vector<T> &v3)
{
#if __cpp_lib_ranges_concat >= 202403L // from C++26
    auto view = std::views::concat(v1, v2, v3);
#else  // C++ 20
#else  // C++ 20
    auto arr = std::array{
        std::views::all(v1),
        std::views::all(v2),
        std::views::all(v3)
    };
    auto view = std::views::join(arr);
#endif

    if constexpr (M == minmax_t::MAX) {
        return std::ranges::max(view);
    } else {
        return std::ranges::min(view);
    }
}

One advantage here is that it works when some of the vectors are empty, as long as there's at least one element in total. It exhibits UB only if all three vectors are empty, compared with the original which is undefined if any one of the vectors is empty.

Using ranges allows us to make the interface more general in a compatible manner by accepting any number of any kind of input range, rather than a fixed number of std::vector:

template <minmax_t M, std::ranges::input_range... R>
constexpr auto get(R&&... ranges)
{
#if __cpp_lib_ranges_concat >= 202403L // from C++26
    auto view = std::views::concat(std::forward<R>(ranges)...);
#else  // C++ 20
    auto arr = std::array{ std::views::all(std::forward<R>(ranges))... , };
    auto view = std::views::join(arr);
#endif
    ⋮

Here's the simple test program I used to exercise the code:

#include <iostream>
#include <string_view>
int main()
{
    using svv = std::vector<std::string_view>;
    svv a{ "foo", "bar", "baz", "quux" };
    svv b{ "green", "yellow", "blue" };
    svv c{ "rough", "hairy", "smooth", "wet" };

    std::cout << get<minmax_t::MIN>(a, b, c) << '\n';
    std::cout << get<minmax_t::MAX>(a, b, c) << '\n';
}

I think it would be better if we created a small set of unit tests to thoroughly exercise the code (what if all inputs are empty, for instance? Should we be returning std::optional<T> instead?).