std::make_signed that accepts floating point types

Question

I have a templated class that can only be instantiated for scalar types (integers, floats, etc.) and I want a member typedef to always be the signed variant of the type. That is:

unsigned int -> signed int
signed long long -> signed long long (already signed)
unsigned char -> signed char
float -> float
long double -> long double
etc...

Unfortunately, std::make_signed only works for integral types, not the floating point types. What is the simplest way to do this? I'm looking for something of the form using SignedT = ...;, to be part of my templated class with template parameter T already guaranteed to be scalar.

Andy Prowl · Accepted Answer · 2013-05-04 18:53:03Z

13

A simple template alias will do:

#include <type_traits>

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

template<typename T>
using try_make_signed =
    typename std::conditional<
        std::is_integral<T>::value,
        std::make_signed<T>,
        identity<T>
        >::type;

And this is how you could test it:

int main()
{
    static_assert(::is_same<
        try_make_signed<unsigned int>::type, int
        >::value, "!");

    static_assert(std::is_same<
        try_make_signed<double>::type, double
        >::value, "!");
}

Here is a live example.

answered May 4, 2013 at 18:53

Andy Prowl

127k25 gold badges394 silver badges455 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

jrok Over a year ago

+1, using is so convenient, I need to finaly update my compiler :)

LB-- · Accepted Answer · 2023-12-07 17:29:31Z

4

@jrok originally had code that could work, only a small adjustment was needed. This is the working code:

template<typename T>
struct YourClass
{
    using SignedT =
        typename std::conditional
        <
            std::is_floating_point<T>::value, //if floating point type
            std::common_type<T>,              //use it as-is
            std::make_signed<T>               //otherwise make sure it is signed
        >::type::type; //notice the double ::type
};

Demo: http://ideone.com/Vw7o82

The above struct could also be modified to itself be a type traits class if this functionality needs to be used multiple times. However, @Andy Prowl's answer does it with an alias template, which is better.

edited Dec 7, 2023 at 17:29

answered May 4, 2013 at 19:32

LB--

3,2283 gold badges40 silver badges82 bronze badges

4 Comments

Andy Prowl Over a year ago

This works, but it has the disadvantage that you have to define it every time. With an alias template like the one in my answer, you could just do using SignedT = typename try_make_signed<T>::type, and you're done.

LB-- Over a year ago

The class in this answer could easily be refactored to itself be a type traits class, so I don't know what you mean by 'disadvantage' - if anything our answers are the same, right?

Andy Prowl Over a year ago

Fair enough, you could modify it to make a type trait out of it, yes - even better if done with an alias template, like in my answer

Andy Prowl Over a year ago

Thank you :) Anyway, interesting use case for std::common_type (although I still believe identity has a better name)

jrok · Accepted Answer · 2013-05-04 19:27:10Z

3

After my initial flawed attempt at using std::conditional, I decided to use SFINAE instead. I'm using std::enable_if to conditionaly enable a specialization for floating point types:

template<typename T, typename Enable = void>
struct my_make_signed {
    typedef typename std::make_signed<T>::type type;
};

template<typename T>
struct my_make_signed<T,
    typename std::enable_if<std::is_floating_point<T>::value>::type> {
    typedef T type;
};

edited May 4, 2013 at 19:27

answered May 4, 2013 at 18:50

jrok

55.5k10 gold badges114 silver badges146 bronze badges

9 Comments

mfontanini Over a year ago

Won't that produce an error if make_signed is not specialized for T? (that's the case for floats).

jrok Over a year ago

@mfontanini my bad, now it won't. Thanks for the heads up.

mfontanini Over a year ago

You're welcome :D. But now your conditional will produce either std::make_signed<T>(for which applying ::type is OK) or T(which can be float, for example) depending on the result of the condition.

jrok Over a year ago

Yeah, i'm fixing it. I'd delete, but can't because it's accepted.

LB-- Over a year ago

@jrok just change it to typename std::conditional<std::is_floating_point<T>::value, std::common_type<T>, std::make_signed<T>>::type::type

|

stardust · Accepted Answer · 2013-05-04 20:10:58Z

0

namespace mine {        

    template<typename T, bool b>
    struct make_signed__ {
        typedef T type;
    };

    template<typename T>
    struct make_signed__<T,false> {
        typedef typename std::make_signed<T>::type type;
    };

    template<typename T>
    struct make_signed {
        typedef typename make_signed__<T, std::is_floating_point<T>::value>::type type;
    };

}

int main () {
    std::cout << std::is_same<mine::make_signed<unsigned int>::type, int>::value;
    std::cout << std::is_same<mine::make_signed<long double>::type, long double>::value;
}

edited May 4, 2013 at 20:10

answered May 4, 2013 at 18:54

stardust

6,0181 gold badge20 silver badges21 bronze badges

5 Comments

LB-- Over a year ago

That's not very portable because it can't support arbitrarily supported types (e.g. a compiler could support std::uint512_t and client code could instantiate my class with that)

stardust Over a year ago

@LB-- Yes that is true. But he only has to define what he uses. By the way does std::make_signed support those?

LB-- Over a year ago

yes, it must because it is defined by the compiler implementation.

stardust Over a year ago

@LB-- Edited. I think it is very portable now.

LB-- Over a year ago

It could do without the macros, then ;)

Collectives™ on Stack Overflow

std::make_signed that accepts floating point types

4 Answers 4

1 Comment

4 Comments

9 Comments

5 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

4 Comments

9 Comments

5 Comments

Your Answer

Sign up or log in

Post as a guest

Related