decltype(*this) equivalent outside function body

Question

Is it possible to write a trait, which results the type of the class it is used in? How to implement get_class in the example below?

class Foo {
    typedef get_class::type type; // type = Foo now
}; 

Note: I have to write a macro, which expands in the class body, used for multiple classes, so I cannot simply write 'typedef Foo type;'

Use case:

I have a reflectable(...) macro which generates infrastructure to iterate over members, visit them and look them up using their names:

class Foo 
{
    friend std::ostream &operator<<(std::ostream &, const Foo&);
    reflectable(
         (int) bar,
         (double) baz
    )
}

reflectable(...) should be a macro so I can get the types and member names separately as strings to build maps for the lookup.

I would like all reflectable class to be streamable, but if I put my reflectable() macro to private section, I have to add the friend declaration to the class. I would like to move it to the macro as:

friend std::ostream &operator<<(std::ostream &, const get_class::type&);

Answer 1

I'm sorry, but I'm pretty sure that in standard C++ there is no way around you having to pass in the class name to the macro one way or another. For some failed attempts, see the end of this answer.

---

That said, I think your best bet is to slightly change your design. Instead of

friend std::ostream &operator<<(std::ostream &, const get_class::type&);

provide a public member function

void stream_to (std::ostream &) const {
  // Implementation
}

together with a free function template

template<typename T, typename std:: enable_if<has_stream_to<T>::value>::type * = nullptr>
std::ostream &operator<<(std::ostream & s, T const & t) {
  t.stream_to(s);
  return s;
}

in your libraries/programs namespace. (Note: I'll add the trait has_stream_to later, for the impatient search for "detect member function" within C++ tag)

---

Approaches that don't work:

• Use a pointer to member function, extract the class type with a template function. Reason: &foo inside of a class with a member function foo won't give a member function pointer to foo. The syntax is required (by the standard) to be &C::foo (where C is the class name...).

• Use a pointer to data member, extract the class type with a template function. Same reason as above.

• Use a dedicated member function that returns *this, deduce the return type to get the class type. Reason: Need an instance to call this function on.

• Use a pointer to a static member function. Reason: Such pointers are same as pointers to free functions, the class name cannot be deduced from them.

• Use the this pointer in a member initialisation. Reason: type of member needs to encode class type somehow, but auto is not allowed for non static data members.

Answer 2

Note: I have to write a macro, which expands in the class body, used for multiple classes, so I cannot simply write 'typedef Foo type;'

If you can expand the macro when declaring the class instead of in the class body, something like this could work:

#include<type_traits>

template<typename T>
struct Type {
    using type = T;
};

#define struct_with_type(S) struct S: Type<S>

struct_with_type(Foo) {};

int main() {
    static_assert(std::is_same<Foo::type, Foo>::value, "!");
}

---

Note that the example proposed with my previous answer isn't valid code:

struct Foo {
    static constexpr auto get_type() -> std::decay_t<decltype(*this)>;
    using type = decltype(get_type());
};

It compiles only with GCC because of a bug of that compiler.
Something I wouldn't use in a production code.

That being said, if you like it, the following compiles and it's something close to that solution:

#include<type_traits>
#include<utility>

#define add_type() constexpr auto type() -> std::decay_t<decltype(*this)>;

template<typename T>
using get_type = decltype(std::declval<T>().type());

struct Foo {
    add_type();
};

int main() {
    static_assert(std::is_same<get_type<Foo>, Foo>::value, "!");
}

Answer 3

It is not a really nice solution, but it might do the trick for you on simple functions. I have not extended it so far for templates and other stuff such as variadic functions:

#define FUNCTION_DECL(R, N, ...) \
        R N(__VA_ARGS__);

#define DEFINE_FRIEND_OPERATOR(CLASS_NAME, MEMBERS)                       \
    friend std::ostream& operator<<(std::ostream& s, CLASS_NAME const& f) \
    {                                                                     \
        std::cout << #CLASS_NAME << ':' << std::endl;                     \
        MEMBERS                                                           \
        return s;                                                         \
    }

#define S_(X) #X
#define S(X) S_(X)

#define STREAM_FUNCTION(R, N, ...) \
    s << "  " #R " " #N S((__VA_ARGS__)) << std::endl;

I do not see any portable way of having the class name other than passing it to the macro, thus the type trait skipped.

You could now place above macros into some appropriate header (and find better/more suitable names...), which would be included for each class. There, you'd have:

class Foo
{
#define FOO_MEMBERS                    \
        MEMBER(int, f0, int, int, int) \
        MEMBER(double, f1, double)     \
        MEMBER(void, f2, char const)

public:
#ifdef MEMBER
#undef MEMBER
#endif
#define MEMBER FUNCTION_DECL
    FOO_MEMBERS
#undef MEMBER

private:
#define MEMBER STREAM_FUNCTION
    DEFINE_FRIEND_OPERATOR(Foo, FOO_MEMBERS)
#undef MEMBER
};

For the map entries, you'd have similar macros, generating an initialiser list in the constructor such as shown here.

Answer 4

As I mentioned in the comments, this sounds like an XY problem. Instead, add a layer of indirection:

class Foo 
{
    friend class reflectable_access;
    reflectable(
         (int) bar,
         (double) baz
    )
};

Now reflectable_access can access the things added by your reflectable macro and expose them to others requiring access to them.