How does this implementation of std::is_class work?

std::is_same implementation
std is_object_v
is_class php

I'm trying to understand the implementation of std::is_class. I've copied some possible implementations and compiled them, hoping to figure out how they work. That done, I find that all the computations are done during compilation (as I should have figured out sooner, looking back), so gdb can give me no more detail on what exactly is going on.

The implementation I'm struggling to understand is this one:

template<class T, T v>
    struct integral_constant{
    static constexpr T value = v;
    typedef T value_type;
    typedef integral_constant type;
    constexpr operator value_type() const noexcept {
        return value;

namespace detail {
    template <class T> char test(int T::*);   //this line
    struct two{
        char c[2];
    template <class T> two test(...);         //this line

//Not concerned about the is_union<T> implementation right now
template <class T>
struct is_class : std::integral_constant<bool, sizeof(detail::test<T>(0))==1 
                                                   && !std::is_union<T>::value> {};

I'm having trouble with the two commented lines. This first line:

 template<class T> char test(int T::*);

What does the T::* mean? Also, is this not a function declaration? It looks like one, yet this compiles without defining a function body.

The second line I want to understand is:

template<class T> two test(...);

Once again, is this not a function declaration with no body ever defined? Also what does the ellipsis mean in this context? I thought an ellipsis as a function argument required one defined argument before the ...?

I would like to understand what this code is doing. I know I can just use the already implemented functions from the standard library, but I want to understand how they work.


What you are looking at is some programming technologie called "SFINAE" which stands for "Substitution failure is not an error". The basic idea is this:

namespace detail {
  template <class T> char test(int T::*);   //this line
  struct two{
    char c[2];
  template <class T> two test(...);         //this line

This namespace provides 2 overloads for test(). Both are templates, resolved at compile time. The first one takes a int T::* as argument. It is called a Member-Pointer and is a pointer to an int, but to an int thats a member of the class T. This is only a valid expression, if T is a class. The second one is taking any number of arguments, which is valid in any case.

So how is it used?


Ok, we pass the function a 0 - this can be a pointer and especially a member-pointer - no information gained which overload to use from this. So if T is a class, then we could use both the T::* and the ... overload here - and since the T::* overload is the more specific one here, it is used. But if T is not a class, then we cant have something like T::* and the overload is ill-formed. But its a failure that happened during template-parameter substitution. And since "substitution failures are not an error" the compiler will silently ignore this overload.

Afterwards is the sizeof() applied. Noticed the different return types? So depending on T the compiler chooses the right overload and therefore the right return type, resulting in a size of either sizeof(char) or sizeof(char[2]).

And finally, since we only use the size of this function and never actually call it, we dont need an implementation.

std::is_class, std::is_class Checks whether T is a non-union class type. Provides the member constant value which is equal to true, if T is a class type (but  The std::is_class type trait is expressed through a compiler intrinsic (called __is_class on most popular compilers), and it cannot be implemented in "normal" C++. Those manual C++ implementations of std::is_class can be used in educational purposes, but not in a real production code.

Part of what is confusing you, which isn't explained by the other answers so far, is that the test functions are never actually called. The fact they have no definitions doesn't matter if you don't call them. As you realised, the whole thing happens at compile time, without running any code.

The expression sizeof(detail::test<T>(0)) uses the sizeof operator on a function call expression. The operand of sizeof is an unevaluated context, which means that the compiler doesn't actually execute that code (i.e. evaluate it to determine the result). It isn't necessary to call that function in order to know the sizeof what the result would be if you called it. To know the size of the result the compiler only needs to see the declarations of the various test functions (to know their return types) and then to perform overload resolution to see which one would be called, and so to find what the sizeof the result would be.

The rest of the puzzle is that the unevaluated function call detail::test<T>(0) determines whether T can be used to form a pointer-to-member type int T::*, which is only possible if T is a class type (because non-classes can't have members, and so can't have pointers to their members). If T is a class then the first test overload can be called, otherwise the second overload gets called. The second overload uses a printf-style ... parameter list, meaning it accepts anything, but is also considered a worse match than any other viable function (otherwise functions using ... would be too "greedy" and get called all the time, even if there's a more specific function t hat matches the arguments exactly). In this code the ... function is a fallback for "if nothing else matches, call this function", so if T isn't a class type the fallback is used.

It doesn't matter if the class type really has a member variable of type int, it is valid to form the type int T::* anyway for any class (you just couldn't make that pointer-to-member refer to any member if the type doesn't have an int member).

How does this implementation of std::is_class work?, I know I can just use the already implemented functions from the standard library, but I want to understand how they work. References: std::is_class std::  The default implementation here returns a string of hex values with the values at the memory space for the class reference passed, while the specializations call std::to_string, this will make any class "stringable". Then you just need to implement your own specialization for your class:

Test is an overloaded function that either takes a pointer to member in T or anything. C++ requires that the best match be used. So if T is a class type it can have a member in it...then that version is selected and the size of its return is 1. If T is not a class type then T::* make zero sense so that version of the function is filtered out by SFINAE and won't be there. The anything version is used and it's return type size is not 1. Thus checking the size of the return of calling that function results in a decision whether the type might have members...only thing left is making sure it's not a union to decide if it's a class or not.

How does this implementation of std :: is_class work?, What you are looking at is some programming technology called "SFINAE", which means "Replacement Error - This Is Not an Error." The basic idea is this: 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 behavior of a program that adds specializations for is_base_of or is_base_of_v (since C++17) is undefined.

Hands-On Design Patterns with C++: Solve common C++ problems with , Before C++11 and constexpr, we would have had to use an enum specifier to T​> struct is_class { enum { value = sizeof(test<T>(NULL)) == 1 }; }; If we work with is_class : std::integral_constant<bool, sizeof(implementation::test<T>(0))  @DanNissenbaum: std::is_class can be implemented without intrinsic, I think. The built-in types are easy to detect (it is a typing exercise for the numeric types which are specialized individually for some trait and uses a few specialization for the pointer and reference types).

The std::is_class type trait is expressed through a compiler intrinsic (called __is_class on most popular compilers), and it cannot be implemented in "normal" C++.

Those manual C++ implementations of std::is_class can be used in educational purposes, but not in a real production code. Otherwise bad things might happen with forward-declared types (for which std::is_class should work correctly as well).

Here's an example that can be reproduced on any msvc x64 compiler.

Suppose I have written my own implementation of is_class:

namespace detail
    template<typename T>
    constexpr char test_my_bad_is_class_call(int T::*) { return {}; }

    struct two { char _[2]; };

    template<typename T>
    constexpr two test_my_bad_is_class_call(...) { return {}; }

template<typename T>
struct my_bad_is_class
    : std::bool_constant<sizeof(detail::test_my_bad_is_class_call<T>(nullptr)) == 1>

Let's try it:

class Test

static_assert(my_bad_is_class<Test>::value == true);
static_assert(my_bad_is_class<const Test>::value == true);

static_assert(my_bad_is_class<Test&>::value == false);
static_assert(my_bad_is_class<Test*>::value == false);
static_assert(my_bad_is_class<int>::value == false);
static_assert(my_bad_is_class<void>::value == false);

As long as the type T is fully defined by the moment my_bad_is_class is applied to it for the first time, everything will be okay. And the size of its member function pointer will remain what it should be:

// 8 is the default for such simple classes on msvc x64
static_assert(sizeof(void(Test::*)()) == 8);

However, things become quite "interesting" if we use our custom type trait with a forward-declared (and not yet defined) type:

class ProblemTest;

The following line implicitly requests the type int ProblemTest::* for a forward-declared class, definition of which cannot be seen by the compiler right now.

static_assert(my_bad_is_class<ProblemTest>::value == true);

This compiles, but, unexpectedly, breaks the size of a member function pointer.

It seems like the compiler attempts to "instantiate" (similarly to how templates are instantiated) the size of a pointer to ProblemTest's member function in the same moment that we request the type int ProblemTest::* within our my_bad_is_class implementation. And, currently, the compiler cannot know what it should be, thus it has no choice but to assume the largest possible size.

class ProblemTest // definition

static_assert(sizeof(void(ProblemTest::*)()) == 24);

The size of a member function pointer was trippled! And it cannot be shrunk back even after the definition of class ProblemTest has been seen by the compiler.

If you work with some third party libraries that rely on particular sizes of member function pointers on your compiler (e.g., the famous FastDelegate by Don Clugston), such unexpected size changes caused by some call to a type trait might be a real pain. Primarily because type trait invocations are not supposed to modify anything, yet, in this particular case, they do -- and this is extremely unexpected even for an experienced developer.

On the other hand, had we implemented our is_class using the __is_class intrinsic, everything would have been OK:

template<typename T>
struct my_good_is_class
    : std::bool_constant<__is_class(T)>

class ProblemTest;

static_assert(my_good_is_class<ProblemTest>::value == true);

class ProblemTest

static_assert(sizeof(void(ProblemTest::*)()) == 8);

Invocation of my_good_is_class<ProblemTest> does not break any sizes in this case.

So, my advice is to rely on the compiler intrinsics when implementing your custom type traits like is_class wherever possible. That is, if you have a good reason to implement such type traits manually at all.

Check Types, template <class T> struct is_union; template <class T> struct is_class; template <class Thanks to the using of the flag std::boolalpha in line 22 the program How does the magic work? I wrote a possible implementation of the function template std::integral. std::integral will check, if the type is integral. If they are related. Let's for a moment assume that B is actually a base of D.Then for the call to check, both versions are viable because Host can be converted to D* and B*.It's a user defined conversion sequence as described by from Host<B, D> to D* and B* respectively.

C++ Template Metaprogramming: Concepts, Tools, and Techniques from , <class T> void f(T x) { if (boost::is_class<T>::value) { implementation 1. is clear and simple, with little or no conceptual overhead—when it works. x) { if (​boost::is_class<T>::value) { std::cout << x::value; // handle integral wrappers } else { So that's how the template parameters of std::function work, at the end it is just a trick to make a lot of parameters look like a function call. Function pointers to that type of function are not necessarily involved in the class.

Templates, C++ FAQ, Mindless repetition is an ideal job for a computer, hence a function template: To call this function with T being an int or a std::string , you could say: #include <​string> One way to implement the above is via template specialization. Instead of  1 Answer 1. Yes you can do it in C using what are referred to as Variadic Functions. The standard printf() and scanf() functions do this, for example. Put the ellipsis (three dots) as the last parameter where you want the 'variable number of parameters to be.

is_class template in C++, The std::is_class template of C++ STL is used to check whether the given type is class or not. It returns a boolean value showing the same. Syntax: template  Stack Exchange network consists of 176 Q&A communities including Stack Overflow, the largest, most trusted online community for developers to learn, share their knowledge, and build their careers. Sign up or log in to customize your list.

  • Function declarations don't contain a body. That's for definitions.
  • Function definitions ARE a function declaration, Karoly. The nit you're picking is that all definitions are declarations, but not all declarations are definitions.
  • What do you mean by "more specific"?
  • @curiousguy: The T::* overload can only be used for expressions that are convertible to a member-pointer. The ... overload could be used for any expression.
  • Is that a standard term?
  • plus 1 for the last three lines.
  • "the other yields 2" at least 2
  • Why at least two?
  • Usually exactly 2, but when is sizeof(struct S) ever guaranteed to have a precise value?