Why can't I use abstract types in tuples I never instantiate?

[LB]

https://ideone.com/Uy49wa
http://coliru.stacked-crooked.com/a/02fa7173c64236a4

#include <iostream>
#include <tuple>
#include <typeinfo>

struct Test
{
	virtual ~Test() = 0;
};
inline Test::~Test() = default;

template<typename T>
void f()
{
	std::cout << typeid(T).name() << std::endl;
}

int main()
{
	f<std::tuple<Test>>();
}

This code fails in both GCC and Clang, even though I am 100% positive it used to work under clang previously. The code never tries to create an instance of the tuple, so why should this code fail? I'm using tuples as type vectors and not being able to use abstract classes is a huge pain.

EDIT: It appears that GCC has had this issue for years:
https://ideone.com/7Qkm2E

EDIT: MSVC accepts the code without issue - I believe when I had it working in clang, clang was using MSVC's standard library.

[coder777]

See this:

http://en.cppreference.com/w/cpp/language/typeid

When applied to an expression of polymorphic type, evaluation of a typeid expression may involve runtime overhead (a virtual table lookup), otherwise typeid expression is resolved at compile time.

I'd say that this requires that the class needs a kind of internal instance.

Does it even make sense to have a name of an object that cannot be an object?

[LB]

In the other example I linked to, typeid is never used and the code still fails with the same error. In my actual code typeid is never used. I just used typeid as an example.

coder777 wrote:

Does it even make sense to have a name of an object that cannot be an object?

Yes, in my case it does. I'm collecting all classes in a hierarchy into a tuple and removing duplicates. Some of the classes are purely abstract but they still need to be included.

[LB]

I just found out it happens with void too: https://ideone.com/1PSGzH

I'm pretty sure it's supposed to be allowed, it must be a standard library implementation bug that's been around for quite a while :(

[JLBorges]

> I'm pretty sure it's supposed to be allowed, it must be a standard library implementation bug

This error is related to the core language; it has nothing to do with implementation details of the standard library.
And AFAIK, it is not a bug; it is an error.

#include <typeinfo>

struct A { virtual void f() const = 0 ; };

template < typename T > struct B { T v ; };

int main()
{
    typeid(A) ; // fine: A can be instantiated as a sub-object
    sizeof(A) ; // fine: A can be instantiated as a sub-object

    typeid( B<A> ) ; // *** may be error: the implementation is not required to maintain type_info objects for 'impossible' types 
    sizeof( B<A> ) ; // *** definite error: sizeof 'impossible' type
}

http://coliru.stacked-crooked.com/a/97c9ddd0450c7e3d
http://rextester.com/TJZHC17968

[LB]

My actual code generates the same error message without using typeid or sizeof.

This is my actual code (condensed): https://ideone.com/pIlQYv

[JLBorges]

> My actual code generates the same error message without using typeid or sizeof

But you are using std::tuple_cat<>

template <class... Tuples>
constexpr tuple<CTypes...> tuple_cat(Tuples&&... tpls);

In the following paragraphs, let T_i be the i^th type in Tuples, U_i be remove_reference_t<T_i>, and tp_i be the i^th parameter in the function parameter pack tpls, where all indexing is zero-based.

Requires: For all i, U_i shall be the type cv_i tuple<Args_i ...>, where cv_i is the (possibly empty) i^th cv-qualifier-seq and Args_i is the parameter pack representing the element types in U_i . Let A_ik be the k_i^th type in Args_i . For all A_ik the following requirements shall be satisfied:

If T_i is deduced as an lvalue reference type, then is_constructible<A_ik , cv_i A_ik&>::value == true,
otherwise is_constructible<A_ik , cv_i A_ik&&>::value == true.

(Emphasis added.)

http://coliru.stacked-crooked.com/a/64f307555deb26b9

[LB]

Ah, I didn't know that restriction existed. I've worked around it by just writing my own tuple type that doesn't store any data. Thanks!