Getting type_info from variadic template breaks the compiler... why?

Question

So I am essentially trying to shove the rtti of a parameter pack into a list of type_info*. But for some reason, it doesn't seem to compile (or rather the compiler gives up half way through). Either way I can't seem to figure it out. Does anyone have a method to fix this, or better yet, know why it's breaking? Anywho, here's the code:

#pragma once
#include <typeinfo>
#include <vector>

class ParamChecker
{
public:
    typedef std::vector<const type_info*> Types;

    template <typename T> void PushType()
    {
        types.push_back(&typeid(T));
    }

    template <typename Head, typename... Tail> void PushTypes()
    {
        PushType<Head>();
        PushTypes<Tail...>();
    }
    void PushTypes() {}

private:
    Types types;
};

Thanks in advance!

What do you mean, breaking the compiler? Does the compiler crash? — DanielKO, Dec 03 '13 at 06:45
Possibly a duplicate of http://stackoverflow.com/questions/3052579/explicit-specialization-in-non-namespace-scope — DanielKO, Dec 03 '13 at 06:45
**Always** copy and paste the error messages and post them so that others see them exactly as you see them. — n. m. could be an AI, Dec 03 '13 at 08:11
Here is the one error I am getting "error C1001: An internal error has occurred in the compiler." — Toms Jensen, Dec 03 '13 at 14:37
Hmmm, found something interesting. If I call the function PushTypes<...>() w/o using a parameter pack and just a couple of types (ie. checker.PushTypes();), I get this error: error C2783: 'void ParamChecker::PushTypes(void)' : could not deduce template argument for 'Head' — Toms Jensen, Dec 03 '13 at 14:56

mpark · Accepted Answer · 2013-12-07T00:45:10.030

I don't have Visual Studio to test, but I see the problem in your code so I'll tell you about that, and you can test on Visual Studio.

The problem is that, when you recurse into PushTypes<Tail...>(); and Tail... is empty, you're calling, PushTypes<>();. Notice that your base case, void PushTypes() {} is not a template function, i.e. you can't call it via PushTypes<>();.

Also note that you'll need a class template as a helper because we don't have partial specializations for function templates yet (hopefully it'll be coming soon).

But here's what you can do.

#include <typeinfo>
#include <vector>

class ParamChecker {
  public:

  /* Our type info structure. */
  using Types = std::vector<const std::type_info *>;

  /* Delegate work to PushTypesImpl<>. */
  template <typename... Types>
  void PushTypes() {
    PushTypesImpl<Types...>()(types_);
  }

  private:

  /* Forward declaration. */
  template <typename... Types>
  class PushTypesImpl;

  /* Collection of type information. */
  Types types_;

};  // ParamChecker

/* Base case. */
template <>
class ParamChecker::PushTypesImpl<> {
  public:

  void operator()(Types &) const { /* Do nothing. */ }

};

/* Recursive case. */
template <typename Head, typename... Tail>
class ParamChecker::PushTypesImpl<Head, Tail...> {
  public:

  void operator()(Types &types) const {
    types.push_back(&typeid(Head));
    PushTypesImpl<Tail...>()(types);
  }

};

int main() {
  ParamChecker x;
  x.PushTypes<>();  // push nothing.
  x.PushTypes<int>();  // push int.
  x.PushTypes<int, double>();  // push int and double.
}

EDIT: The following is an alternative approach using type_list and passing it as an argument.

NOTE: The use of type_list<> here instead of tuple<> is because constructing an empty tuple requires that all of the types be default-constructable, and even if they were all default-constructable, we don't want to default-construct them for no reason.

template <typename... Types>
class type_list {};

class ParamChecker {
  public:

  /* Our type info structure. */
  using Types = std::vector<const std::type_info *>;

  /* Base case. Do nothing. */
  void PushTypes(type_list<> &&) {}

  /* Recursive case. */
  template <typename Head, typename... Tail>
  void PushTypes(type_list<Head, Tail...> &&) {
    types_.push_back(&typeid(Head));
    PushTypes(type_list<Tail...>());
  }

  private:

  /* Collection of type information. */
  Types types_;

};  // ParamChecker

int main() {
  ParamChecker x;
  x.PushTypes(type_list<>());  // push nothing.
  x.PushTypes(type_list<int>());  // push int.
  x.PushTypes(type_list<int, double>());  // push int and double.
}

Hmmm... Thanks for the input. I have gotten something running with the help of tuples, but I'll still try to get around to testing this. I dont have access to my pc today though, so I'll have to wait till tomorrow :/ — Toms Jensen, Dec 05 '13 at 20:49
Did you make the `PushTypes` function take a tuple as a parameter? — mpark, Dec 06 '13 at 01:15
Yes. That way the parameter pack was contained and easier to work with. Plus, since it was contained, the compiler did not get confused. — Toms Jensen, Dec 07 '13 at 00:20
I'm guessing that your solution looks like, `void PushTypes(std::tuple<> &&);` and `void PushTypes(std::tuple &&);`, with the call-site looking like: `PushTypes(std::tuple());`. Personally I think `PushTypes()` is a cleaner interface, even though the implementation being uglier, I prefer usually that the call-site be clean. However, if you decide that you still favor the `tuple` approach, then consider using a `type_list` instead. — mpark, Dec 07 '13 at 00:38
Yes this is essentially what I came up with, minus the fact that I was using a tuple. Thanks for spending the time to help out! — Toms Jensen, Dec 07 '13 at 01:48

Getting type_info from variadic template breaks the compiler... why?

1 Answers1