Implementing Same Function for Different Types

Question

I want to implement same function for different data types of 16, 32 and 64 bits. There are fields in functions that vary depending on the input bit width. I show my implementation below. Is there any other way to realize this? You can comment on other things you see in the code as well.

uint64_t floatAngleToBinary64Angle(float fFloatAngle)
{
    const float fScaleMultiplier0 = 64.0/45.0;
    const float fScaleMultiplier1 = std::pow(2, 64 - 9); // 64 for 64bits
    return ((uint64_t)(fFloatAngle * fScaleMultiplier0 * fScaleMultiplier1));
}

uint32_t floatAngleToBinary32Angle(float fFloatAngle)
{
    const float fScaleMultiplier0 = 64.0/45.0;
    const float fScaleMultiplier1 = std::pow(2, 32 - 9); // 32 for 32bits
    return ((uint32_t)(fFloatAngle * fScaleMultiplier0 * fScaleMultiplier1));
}

uint16_t floatAngleToBinary16Angle(float fFloatAngle)
{
    const float fScaleMultiplier0 = 64.0/45.0;
    const float fScaleMultiplier1 = std::pow(2, 16 - 9); // 16 for 16bits
    return ((uint16_t)(fFloatAngle * fScaleMultiplier0 * fScaleMultiplier1));
}

@melk: Except for template functions, (that indeed doesn't apply to OP's case). — Jarod42
– Jarod42, Commented Apr 21, 2020 at 15:30

joshwilsonvu · Accepted Answer · 2020-04-21 15:17:32Z

9

You can't overload return types, but you can reuse the implementation with a template function:

template <typename T>
T floatAngleImpl(float fFloatAngle)
{
    const float fScaleMultiplier0 = 64.0/45.0;
    const float fScaleMultiplier1 = std::pow(2, sizeof(T)*8 - 9); // number of bits in type T
    return ((T)(fFloatAngle * fScaleMultiplier0 * fScaleMultiplier1));
}

uint64_t floatAngleToBinary64Angle(float fFloatAngle)
{
    return floatAngleImpl<uint64_t>(fFloatAngle);
}

uint32_t floatAngleToBinary32Angle(float fFloatAngle)
{
    return floatAngleImpl<uint32_t>(fFloatAngle);
}

uint16_t floatAngleToBinary16Angle(float fFloatAngle)
{
    return floatAngleImpl<uint16_t>(fFloatAngle);
}

answered Apr 21, 2020 at 15:17

joshwilsonvu

2,71911 silver badges21 bronze badges

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

Comments

Quentin · Accepted Answer · 2020-04-21 15:25:27Z

You can't overload functions on their return type alone, but you can return an object which defers the calculation to when the destination type is known:

auto floatAngleToBinaryAngle(float fFloatAngle) {
    struct converter {
        float fFloatAngle;

        operator uint64_t () const
        {
            const float fScaleMultiplier0 = 64.0/45.0;
            const float fScaleMultiplier1 = std::pow(2, 64 - 9); // 64 for 64bits
            return ((uint64_t)(fFloatAngle * fScaleMultiplier0 * fScaleMultiplier1));
        }

        operator uint32_t () const
        {
            const float fScaleMultiplier0 = 64.0/45.0;
            const float fScaleMultiplier1 = std::pow(2, 32 - 9); // 32 for 32bits
            return ((uint32_t)(fFloatAngle * fScaleMultiplier0 * fScaleMultiplier1));
        }

        operator uint16_t () const
        {
            const float fScaleMultiplier0 = 64.0/45.0;
            const float fScaleMultiplier1 = std::pow(2, 16 - 9); // 16 for 16bits
            return ((uint16_t)(fFloatAngle * fScaleMultiplier0 * fScaleMultiplier1));
        }
    };

    return converter{fFloatAngle};
}

// Usage
uint32_t angle = floatAngleToBinaryAngle(2.1f);

SomeWittyUsername · Accepted Answer · 2020-04-21 15:49:17Z

2

More compact suggestion:

#include <type_traits>

template <typename T>
T floatAngleToBinary(float fFloatAngle)
{
    static_assert(std::is_same<uint64_t,T>() || std::is_same<uint32_t,T>() || std::is_same<uint16_t,T>(),"unsupported type");

    const float fScaleMultiplier0 = 64.0/45.0;
    const float fScaleMultiplier1 = std::pow(2, sizeof(T) * 8 - 9);
    return ((T)(fFloatAngle * fScaleMultiplier0 * fScaleMultiplier1));
}

Execution examples for different types:

uint64_t a = floatAngleToBinary<uint64_t>(fFloatAngle);
return floatAngleToBinary<uint32_t>(fFloatAngle);
uint16_t b = 5 + floatAngleToBinary<uint16_t>(fFloatAngle);

edited Apr 21, 2020 at 15:49

answered Apr 21, 2020 at 15:32

SomeWittyUsername

18.4k3 gold badges46 silver badges87 bronze badges

Comments

cigien · Accepted Answer · 2020-04-21 15:16:02Z

1

You can't overload functions on the return type. One option is to have the differing type as an argument, e.g.

void floatAngleToBinary64Angle(uint64_t &ans, float fFloatAngle)
{
 // ...
 ans = ...
}

and then you can call your function like this:

unit64_t a;
floatAngleToBinary64Angle(a, 4.2);

answered Apr 21, 2020 at 15:16

cigien

61.2k11 gold badges86 silver badges124 bronze badges

Collectives™ on Stack Overflow

Implementing Same Function for Different Types

4 Answers 4

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related