Templated is_in() function (check if array contains string) in C++

user_1658105 0
Viewed 191

I would like to do the following:

std::string b = "b";
is_in("a", { "a", "b", "c" });
is_in("d", { "a", "b", "c" });
is_in(b, { "a", "b", "c" }); // fails
is_in(b, std::array{ "a", "b", "c" });

using the templates

template<typename Element, typename Container>
bool is_in(const Element& e, const Container& c)
{
    // https://stackoverflow.com/questions/20303821/how-to-check-if-string-is-in-array-of-strings
    return std::find(std::begin(c), std::end(c), e) != std::end(c);
}

template<typename Element>
bool is_in(Element e, std::initializer_list<Element> l)
{
    // return std::find(std::begin(l), std::end(l), e) != std::end(l);
    return is_in<Element, std::initializer_list<Element>>(e, l);
}

but I get the following error (using GCC 9.3.0):

no matching function for call to ‘is_in(std::string&, <brace-enclosed initializer list>)’

Any big brain template fellas out there got suggestions?

templates gcc arrays c++ string
2 Answers

For is_in(b, { "a", "b", "c" });, template parameter Element is deduced as std::string on the 1st argument b, and deduced as const char* on the 2nd argument { "a", "b", "c" }; they don't match.

You can give two template parameters for is_in, e.g.

template<typename E1, typename E2>
bool is_in(E1 e, std::initializer_list<E2> l)
{
    // return std::find(std::begin(l), std::end(l), e) != std::end(l);
    return is_in<E1, std::initializer_list<E2>>(e, l);
}

Or use std::type_identity (since C++20; and it's quite easy to write one for pre-C++20) to exclude the 2nd function parameter from type deduction.

template<typename Element>
bool is_in(Element e, std::initializer_list<std::type_identity_t<Element>> l)
{
    // return std::find(std::begin(l), std::end(l), e) != std::end(l);
    return is_in<Element, std::initializer_list<Element>>(e, l);
}
user_33097900

Another approach that involves converting unmatching string types to std::string before comparing them.

#include <cassert>
#include <array>
#include <string>

// Help the compiler figure out to compare "unrelated" string types
namespace details
{
    template<typename type_t>
    struct compare_as
    {
        using type = type_t;
    };

    template<std::size_t N>
    struct compare_as<char[N]>
    {
        using type = std::string;
    };

    template<>
    struct compare_as<char*>
    {
        using type = std::string;
    };
}

// template for "array" style parameters 
template<typename type_t, typename coll_t, std::size_t N>
constexpr auto is_in(const type_t& value, const coll_t(&values)[N])
{
    for (const auto& v : values)
    {
        typename details::compare_as<coll_t>::type lhs{ v };
        typename details::compare_as<type_t>::type rhs{ value };
        if (lhs == rhs) return true;
    }

    return false;
}

// template for containers
template<typename type_t, typename coll_t>
constexpr auto is_in(const type_t& value, const coll_t& values)
{
    for (const auto& v : values)
    {
        typename details::compare_as<type_t>::type lhs{ v };
        typename details::compare_as<type_t>::type rhs{ value };
        if (lhs == rhs) return true;
    }

    return false;
}

int main()
{
    // for non-string types compile time checking is possible
    static_assert(is_in(1, { 1,2,3 }));

    std::string b = "b";
    assert(is_in("a", { "a", "b", "c" }));
    assert(!is_in("d", { "a", "b", "c" }));
    assert(is_in(b, { "a", "b", "c" }));
    assert(is_in(b, std::array{ "a", "b", "c" }));
}
user_166495500
Related