How to check if two types are same at compiletime(bonus points if it works with Boost strong typedef)

Question

I was wondering if it is possible to check if 2 types are same at compile time. What I came up with is(idk if it works because it feels hackish and IDK standard that good so IDK what to look for when testing).

#include <boost/strong_typedef.hpp>
BOOST_STRONG_TYPEDEF(double, cm);
BOOST_STRONG_TYPEDEF(double, inch);
template<typename T, typename U>
static constexpr void __help() 
{
}
template<typename T, typename U>
class AreSameType
{
    public:
    constexpr operator bool()
    {
     return &__help<T,U> == &__help<U,T>;
    };
};

usage :

int main()
{
        static_assert(AreSameType<double,float>()== false, "oh noes1");
        static_assert(AreSameType<double,double>()== true, "oh noes2");
        static_assert(AreSameType<int*,double*>()== false, "oh noes3");
        static_assert(AreSameType<double*,double>()== false, "oh noes4");
        static_assert(AreSameType<const double,double>()== false, "oh noes5");
        static_assert(AreSameType<inch,cm>()== true, "oh expected"); //fires
}

So

1) is there a better way to it?
2) is this address of a function hack guaranteed to work by standard(I would bet not :))?

like std::is_same, just tested it, it is really really *strong* typedef — NoSenseEtAl, Oct 25 '12 at 15:04
I support Xeo's remark here, the very idea of `BOOST_STRONG_TYPEDEF` is to create a type that cannot be accidentally misconstrued with its "origin". Did you thought about using `Boost.Unit` for your units ? — Matthieu M., Oct 25 '12 at 15:06
@MatthieuM - yeah, that is what I want, maybe source is confusing, sorry for that — NoSenseEtAl, Oct 25 '12 at 15:08

score 60 · Accepted Answer · answered Oct 25 '12 at 14:56

60

Use std::is_same. std::is_same<T,U>::value will be true if T and U are the same type, false otherwise.

If you don't have C++11, it's easy to implement as this

template<class T, class U>
struct is_same {
    enum { value = 0 };
};

template<class T>
struct is_same<T, T> {
    enum { value = 1 };
};

answered Oct 25 '12 at 14:56

Dirk Holsopple

8,731
1
24
37

2

Or as easy as using `boost::is_same`. – Xeo Oct 25 '12 at 15:01
1

cool, i wanted to try something like that but I had troubles figuring out how to specialize(wrong word?) template when both types are same... i tried stupid template nad template <> – NoSenseEtAl Oct 25 '12 at 15:06
2

@NoSenseEtAl: specialize is the right word. Here you see a partial specialization (ie, there are still template parameters) whilst `template <>` indicates a full specialization (no more template parameters: thus all types/values are known). – Matthieu M. Oct 25 '12 at 15:24
3

`#include ` also reference: http://en.cppreference.com/w/cpp/types/is_same – thejoshwolfe Feb 17 '16 at 19:03
3

note that since c++17 we have a nicer is_same_v that removes the need for ::value – NoSenseEtAl Nov 24 '17 at 06:30
What a genius you are. – Zhang Sep 19 '18 at 05:58

How to check if two types are same at compiletime(bonus points if it works with Boost strong typedef)

1 Answers1

Linked