SelfType in Macro.

[Wu zhen hai]

some days ago, I write a macro that needs '(*this)' type.

#include <iostream>
#include <type_traits>
#define GenerateSelfType() using SelfType = std::remove_reference_t<decltype(*this)>;
struct A
{
	GenerateSelfType()
};
int main()
{}

The above code compiled fail. The main reason is that 'this' is not in the right place.

I need the macro is independent of the specific class, such as 'A'.

So I write a substitute.

#include <iostream>
#include <type_traits>

template<class Self>
struct MemberFunctionParse;

template<class Result, class Self, class... Args>
struct MemberFunctionParse<Result(Self::*)(Args...)>
{
	using SelfType = Self;
};

#define GenerateSelfType()\
private:\
auto SelfTypeNeverUseManually()->std::remove_reference_t<decltype(*this)>;\
public:\
using SelfType = MemberFunctionParse<decltype(&SelfTypeNeverUseManually)>::SelfType;
struct A
{
	GenerateSelfType()
};
struct B : public A
{
	GenerateSelfType()
};
int main()
{
	static_assert(std::is_same<B, B::SelfType>::value,"bad");
	static_assert(std::is_same<A, A::SelfType>::value,"bad");
}

g++ needs '-fpermissive'.


Who can privode more simple method?

[gunnerfunner]

# include <iostream>
# include <type_traits>
# include <iomanip>

struct A{};

int main()
{
    std::cout << std::boolalpha << std::is_same <A, A&>() << "\n"; //false
    std::cout << std::is_same <A, std::remove_reference<A&>::type>() << "\n"; //true
    std::cout << std::is_same <A, std::remove_reference<A&&>::type>() << "\n"; //true

    std::cout << "\n\n";

    std::cout << std::is_same <A, A&> () << "\n"; //false
    std::cout << std::is_same <A, std::remove_reference_t<A&>> () << "\n"; //true
    std::cout << std::is_same <A, std::remove_reference_t<A&&>> () << "\n"; //true

}

[Wu zhen hai]

Are you answering my questions?

[gunnerfunner]

Are you answering my questions?

yeah, I was hoping I was but since you're asking probably not? In that case, do clarify and while you do so permit me another interpretation of the problem which I think is quite interesting:

# include <iostream>
# include <type_traits>
# include <iomanip>

struct A{A* a;};
struct B{};

template <typename T> struct has_own_pointer : std::false_type{};

template <> struct has_own_pointer <A> : std::true_type{};

int main()
{
    std::cout << std::boolalpha << has_own_pointer<B> :: value << "\n";
    std::cout << has_own_pointer<A> :: value << "\n";
}

Here I'm assuming your SelfType is akin to a pointer to the same type (obviously it can't be an object of the same type since that'd result in an incomplete type)

[Wu zhen hai]

I want to get the current type of the current specific type in a macro.

the macro is independent of the specific type.