Why can't "is_base_of" be used inside a class declaration (incomplete type)?

Question

I completely see why this cannot work:

class Base {};
class A;
static_assert(std::is_base_of<Base, A>::value, "");

Because there is no information about a 'class hierarchy', but... Why cannot the following work?

class Base {};
class A : public Base {
    static_assert(std::is_base_of<Base, A>::value, "");
};
(produce: an undefined class is not allowed as an argument to compiler intrinsic type trait)

The type 'A' is still not complete at line with static_assert (according to definition of this concept). However - the compiler already knows the 'class hierarchy' and could provide the answer for this.

Of course - this static_assert could be moved to destructor or whatever to fix this issue, but there are situations where it cannot be done, for example:

class Base {};

template<typename T>
struct type_of {
    static_assert(std::is_base_of<Base, T>::value, "T is not derived from Base");
    using type = int; //* Some normal type in real use
};

class A : public Base {
public:
    type_of<A>::type foo(); // Will not compile
};

Should it not be allowed?

`the compiler already knows the 'class hierarchy'` Yes, but `std::is_base_of` is not a core feature, but a *library* feature, which makes things more complicated. — DeiDei, Feb 06 '18 at 12:58
@DeiDei: In other words, "because C++ is one giant abstraction leak after another"? ;) — Lightness Races in Orbit, Feb 06 '18 at 17:53
Currently is_base_of is a perfectly ordinary class template. In order to implement your idea you would need a special magic implementation of is_base_of and a special permission of the standard to perform this magic. The standard is already too big as is. We don't want to make it even bigger and more complicated for marginal benefit. — n. 'pronouns' m., Feb 06 '18 at 19:08
_We don't want to make it even bigger and more complicated_ @n.m. Please speak for yourself :p No big magic - just logic :) If a feature does not need to know everything about the class, just its 'class hierarchy' - why it does.. — user2561762, Feb 06 '18 at 21:55
The only 'new thing' required from compiler is to provide not only the sizeof(type), which is used to check if type is complete, but also - mechanism to recognize the moment when 'class hierarchy' was declared. For example, MSVS already 'does it'. If I use std::is_convertible inside a class declaration - it works, so compiler has this information. The only missing part is that this is 'private' to this compiler. And btw. - this will be probably required in a future feature of std::bases https://gcc.gnu.org/onlinedocs/gcc-4.7.1/libstdc++/api/a00907.html (if will ever be released :p ) — user2561762, Feb 07 '18 at 07:53
This proposal was rejected. By the way I am not notified about your comments. To notify a user use this notation: @username. — n. 'pronouns' m., Feb 07 '18 at 15:01

skypjack · Answer 1 · 2018-02-06T16:47:35.333

A class definition is complete (that is, a class is considered defined) after the closing brace }.
In your case, when you try to use A with std::is_base_of, A isn't fully defined yet:

class A : public Base {
    // no closing brace for A yet, thus A isn't fully defined here
    static_assert(std::is_base_of<Base, A>::value, "");
};

On the other side, std::is_base_of requires types that are completely defined to work.
Thus the error.

As a workaround, you can put the assert in the destructor of A:

class A : public Base {
    ~A() {
        static_assert(std::is_base_of<Base, A>::value, "");
    }
};

In fact, a class type is considered fully defined in its member functions' bodies.

See here for more details (emphasis mine):

A class is considered a completely-defined object type ([basic.types]) (or complete type) at the closing } of the class-specifier. Within the class member-specification, the class is regarded as complete within function bodies, default arguments, noexcept-specifiers, and default member initializers (including such things in nested classes). Otherwise it is regarded as incomplete within its own class member-specification.

" _a class type is considered fully defined in its member functions' bodies_ " ... that's a good, insightful point! — Eljay, Feb 06 '18 at 13:27
See [here](http://eel.is/c++draft/class#mem-6) - _A class is considered a completely-defined object type ([basic.types]) (or complete type) at the closing } of the class-specifier. Within the class member-specification, the class is regarded as complete within function bodies, default arguments, noexcept-specifiers, and default member initializers (including such things in nested classes). Otherwise it is regarded as incomplete within its own class member-specification._ — skypjack, Feb 06 '18 at 13:29

Mateusz Grzejek · Answer 2 · 2018-02-06T16:08:18.903

7

The doc page for std::is_base_of yields:

If both Base and Derived are non-union class types, and they are not the same type (ignoring cv-qualification), Derived shall be a complete type; otherwise the behavior is undefined.

The definition for a class is complete after you close its scope with }. Thus, in your case, an error is generated.

Note, that static assertion can appear in block or namespace / file scope. So you can move it outside the class' body or, if you don't want to have it in your header, move to the implementation file.

edited Feb 06 '18 at 16:08

answered Feb 06 '18 at 12:59

Mateusz Grzejek

10,635
3
30
47

1

Question is asking _why_ this is the case, not just for affirmation that it is. – Lightness Races in Orbit Feb 06 '18 at 17:54

Why can't "is_base_of" be used inside a class declaration (incomplete type)?

2 Answers2

Linked