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

Question

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?

songyuanyao · Accepted Answer · 2021-10-15 08:08:35Z

7

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);
}

edited Oct 15, 2021 at 8:08

answered Oct 15, 2021 at 7:56

songyuanyao

174k16 gold badges327 silver badges432 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Androvich Over a year ago

Oh, that makes perfect sense, thanks a bunch! Can you link me how to rewrite std::type_identity?

Jarod42 Over a year ago

@Androvich: link provides possible implementation.

songyuanyao Over a year ago

@Androvich Possible implementation

Pepijn Kramer · Accepted Answer · 2021-10-15 09:15:40Z

1

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" }));
}

edited Oct 15, 2021 at 9:15

answered Oct 15, 2021 at 8:51

Pepijn Kramer

14k4 gold badges12 silver badges27 bronze badges

2 Comments

Androvich Over a year ago

Oh, that's pretty neat. But wouldn't it be better to keep it more generic, such that it can be used with primitives and std::string? Or any type that std::find works with, actually.

Pepijn Kramer Over a year ago

Probably yes :) As said this was just a few minutes worth of effort. And most types are actually comparable it is just that arrays of characters (string literals) in c++ are so messy.

Caduchon · Accepted Answer · 2025-11-21 15:54:42Z

0

From C++17, you can do something similar with variadic template and fold expressions :

template <typename T, typename... Ts>
bool is_in(T const& x, Ts const&... y)
{
  return ((x == y) ||...);
}

And call it :

is_in("a", "a", "b", "c");

answered Nov 21 at 15:54

Caduchon

5,2785 gold badges28 silver badges75 bronze badges

Collectives™ on Stack Overflow

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

3 Answers 3

3 Comments

2 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related