有没有办法让32位C ++编译器遵循16位整数提升规则？

Question

With the following code:

#include <stdint.h>

uint16_t test() {
    uint16_t a = 1000;
    uint16_t b = 1000;
    uint16_t c = 100;
    return (a * b) / c;
}

A compiler targeting a 32bit machine will return 10000, but one targeting a 16 bit machine will return 169. The behavior is explained by C's integer promotion rules.

This is a problem when unit testing firmware for a 8 or 16 bit machine on a desktop PC.

Right now, either casting every multiplication or putting it inside a function returning the same type are the only options I can think of. Ideally some compiler switch would exist, but I haven't seen one.

Happy with a solution for either GCC, Clang or MSVC.

Answer 1

This could be an XY problem . Depends on your specific work.

While unit testing on a desktop machine for a different architecture could help, I doubt this is the way. Even if you found some switches in the compiler to simulate on x86 some rules for other architecture, you can never be sure that the simulated behavior will be the same as in the real environment. Furthermore there certainly will be other differences (some you can predict, some you cannot) on behavior between the target architecture and the testing architecture.

So in conclusion, testing on an architecture and expecting it to work on another is not reliable, not in a real way anyway. So the solution should be to test on the target architecture. Get an emulator, or a VM, or a remote device on which you can unit test on the real environment.

If that is not a viable option, instead of trying to make unit testing match the real environment from a pc environment, you could just live with these differences, take into account that unit tests are not very reliable and use them just for limited testing, and rely more on integration testing, which should be on the target architecture.

Answer 2

No, there isn't any way to do what you're asking.

Right now, either casting every multiplication or putting it inside a function returning the same type are the only options I can think of.

Another option is avoiding using multiple operations in a single expression, implicitly forcing a conversion back to uint16_t :

uint16_t test() {
    uint16_t a = 1000;
    uint16_t b = 1000;
    uint16_t c = 100;
    a *= b;
    a /= c;
    return a;
}

Or, using a function, that function could be an overloaded operator to keep the code readable:

#include <stdint.h>

template <typename T>
struct unpromoted
{
   T value;

   unpromoted() = default;
   unpromoted(T value) : value(value) { }
   explicit operator T() { return value; }

   friend unpromoted operator*(unpromoted a, unpromoted b)
   { return a.value * b.value; }

   friend unpromoted operator/(unpromoted a, unpromoted b)
   { return a.value / b.value; }

   // add other operators as well
};

using uuint16_t = unpromoted<uint16_t>;

uuint16_t test() {
    uuint16_t a = 1000;
    uuint16_t b = 1000;
    uuint16_t c = 100;
    return (a * b) / c; // returns 169
}

Note that this does require a cast when eg adding an uuint16_t and an uuint8_t . It's possible to let that return an uuint16_t , but I probably wouldn't bother with it.