C++: recursively match argument type with class template type

user_16059253 0
Viewed 62

I am hoping to achieve such type matching function:

    MyClass<int, bool> temp;
    temp.print(-1, false);           // works
    temp.print(-1);                  // compile error, too less argument
    temp.print(-1, "string");        // compile error, wrong type
    temp.print(-1, false, 'c');      // compile error, too many arguments

Basically, when given template parameter, MyClass's function print accepts arguments of exactly the same type, no more, no less.

And this is my current implementation:

template<class... ClassType>
class MyClass {
public:
    template<typename... ArgType>
    void print(ArgType... args) {
        matchType<ClassType...>(args...);
    }

private:
    template<typename Type>
    void matchType(Type t) {
        std::cout << "matching " << t << "\n";
        std::cout << "end\n";
    }

    template<typename FirstType, typename... Rest>
    void matchType(FirstType firstArg, Rest... args) {
        std::cout << "matching " << firstArg << "\n";
        matchType<Rest...>(args...);
    }
};

But it fails to detect and match type that it compiles well for the code:

    MyClass<int, bool> temp;
    temp.print(-1, false);           // works
    temp.print(-1, "string");        // works, shouldn't work
    temp.print(-1, false, 'c');      // works, shouldn't work

Can someone explain to me what have I done wrong?

live code

templates c++
2 Answers
#include <iostream>

template<class... ClassType>
class MyClass {
public:
    template<typename... ArgType>
    void print(ArgType... args) = delete;

    void print(ClassType ... args) {
        std::cout << "works\n";
    }
};

int main()
{
    MyClass<int, bool> temp;
    temp.print(-1, false);            // ok

    temp.print(-1);                   // error
    temp.print(-1, "string");         // error
    temp.print(-1, false, 'c');       // error
    temp.print(-1L, false);           // error
}
user_7758060

To make it work, you have to check at compile time that ArgType... and ClassType... are the same. This does the job:

#include <type_traits>
#include <utility>
#include <tuple>

template<class... ClassType>
class MyClass {
private:
    template <typename... ArgType, std::size_t... I>
    static constexpr bool check_type_impl(std::index_sequence<I...>) {
        return (std::is_same_v<typename std::tuple_element<I, std::tuple<ClassType...>>::type,
                               typename std::tuple_element<I, std::tuple<ArgType...>>::type> && ...); }

    template <typename... ArgType>
    static constexpr bool check_type() {
        return (sizeof...(ArgType) == sizeof...(ClassType)) &&
                check_type_impl<ArgType...>(std::index_sequence_for<ClassType...>{});
        }

public:
    template<typename... ArgType, class = std::enable_if_t<check_type<ArgType...>()>>
    void print(ArgType... args) {
    }

};

int main()
{
  MyClass<int, bool> temp;
  temp.print(-1, false);           // works
  //temp.print(-1);                  // compile error, too less argument
  //temp.print(-1, "string");        // compile error, wrong type
  //temp.print(-1, false, 'c');      // compile error, too many arguments
};

See it Live on Coliru.

The member function check compares one-by-one the type of ArgType... and ClassType.... It does that by passing to check_impl an std::index_sequence of indices from 0 to sizeof...(ClassType). check_impl returns true if the I-th types are identical. See this question for the use of std::tuple_element to extract the type of I-th element of a variadic pack.

user_87699850
Related