Creating custom sizeof() that returns narrower types

user_881814 0
Viewed 110

The Issue

sizeof returns size_t type, so when passed as argument to functions that takes in narrower types (e.g. unsigned char), implicit conversion occurs. In many cases these are 3rd party library functions, so their prototypes are beyond my control. Compilers are now typically smart enough to detect whether such conversions would really cause truncation and warn you about it, but some static code analyzers will still flag such cases out, leading to lots of false positives. Explicitly casting the result of sizeof typically resolves the analysis warnings but it would hide the compiler warnings, not to mention that it makes things clunky.

My Solution

template<class T1, class T2>
struct sizeofxx {
    static constexpr T2 value{ sizeof(T1) };
};

template <class T>
constexpr unsigned int sizeof32 = sizeofxx<T, unsigned int>::value;

template <class T>
constexpr unsigned short sizeof16 = sizeofxx<T, unsigned short>::value;

template <class T>
constexpr unsigned char sizeof8 = sizeofxx<T, unsigned char>::value;

Usage:

unsigned int foo = sizeof32<float>;
const char bar[255];
unsigned char foo3 = sizeof8<decltype(bar)>;

It relies on aggregate initialization to guard against narrowing conversion at compile time. So if I had used bar[256], the build fails.

Limitation

But as you can see, using it on variables is rather clunky (due to the need for decltype). Is there a simpler way to do this? I know one way is wrap it in a macro, but this would prevent IDEs like Visual Studio from helping you resolve the value when you mouseover it. Another way is to create a constexpr function:

template <class T1>
constexpr unsigned char sizeof8f(T1&) {
    return sizeof(T1);
}

But this also does not allow for IDE code-time resolution, and would expand the number of symbols involved since they need to be of different names from the earlier implementation that operates on types.

Any other suggestions on resolving the root issue (static code analysis warnings) are welcomed. And no, suppressing them is not feasible.

templates c++
4 Answers

For your specific problem, there need not be any runtime checks even on debug builds as some has suggested, since the value is itself a constexpr. You can write a simple utility to cast a value to the smallest type that is able to hold it.

template<size_t N>
inline constexpr auto minuint = []{
    if constexpr(N >= 1ull << 32)
        return N;
    else if constexpr(N >= 1ull << 16)
        return uint32_t(N);
    else if constexpr(N >= 1ull << 8)
        return uint16_t(N);
    else
        return uint8_t(N);
}();

On the other hand, no function or template can ever accept both expressions and types. The only possible way to imitate sizeof behaviour is to use a macro.

#define Sizeof(x) minuint<sizeof(x)>

With this, you never get false warnings on narrowing conversions: if there is a warning, you are doing something wrong.

user_48324990

The compiler would most likely optimize out the function, even without constexpr example on godbolt

you may want to use T&& or const T& so it bind to an rvalue, depend on what you want.

template<typename size_type,typename T>
constexpr size_type sizeofxx(T&& t){
    return sizeof(T);
}
user_59804300

How about this

template<typename size_type, typename object_type>
constexpr size_type
sizeof_as(object_type& object) {
    // TODO: static_assert(...)
    return size_type{sizeof object};
}

auto foo = ...; // some object
auto size = sizeof_as<uint8_t>(foo);

First template parameter is given explicitly, second one deduced from the argument.

Maybe add to that another function that doesn't require an object but just its type, similar to the second sizeof syntax:

template<typename size_type, typename object_type>
constexpr size_type
sizeof_as() {
    // TODO: static_assert(...)
    return size_type{sizeof (object_type)};
}
user_19681820

Passer By's solution requires at least C++17 to work and it just occurred to me that a C++11 solution is also possible. The approach is to use SFINAE to let the compiler pick the appropriate function overload for every invocation:

template<size_t S, std::enable_if_t<S <= 0xFFull, int> = 0>
constexpr auto mintype() { return (uint8_t)S; }

template<size_t S, std::enable_if_t<0xFFull < S && S <= 0xFFFFull, int> = 0>
constexpr auto mintype() { return (uint16_t)S; }

template<size_t S, std::enable_if_t<0xFFFFull < S && S <= 0xFFFFFFFFull, int> = 0>
constexpr auto mintype() { return (uint32_t)S; }

template<size_t S, std::enable_if_t<0xFFFFFFFFull < S, int> = 0>
constexpr auto mintype() { return S; }

#define sizeofex(S) mintype<sizeof(S)>()

Still, it requires a macro for ease of use. We can avoid the macro by tweaking the implementation a bit, at the cost of doubling the code required:

// Overloads for variables
template<class T, std::enable_if_t<sizeof(T) <= 0xFFull, int> = 0>
constexpr uint8_t sizeofex(const T&) { return sizeof(T); }

template<class T, std::enable_if_t<0xFFull < sizeof(T) && sizeof(T) <= 0xFFFFull, int> = 0>
constexpr uint16_t sizeofex(const T&) { return sizeof(T); }

template<class T, std::enable_if_t<0xFFFFull < sizeof(T) && sizeof(T) <= 0xFFFFFFFFull, int> = 0>
constexpr uint32_t sizeofex(const T&) { return sizeof(T); }

template<class T, std::enable_if_t<0xFFFFFFFFull < sizeof(T), int> = 0>
constexpr uint64_t sizeofex(const T&) { return sizeof(T); }

// Overloads for types
template<class T, std::enable_if_t<sizeof(T) <= 0xFFull, int> = 0>
constexpr uint8_t sizeofex() { return sizeof(T); }

template<class T, std::enable_if_t<0xFFull < sizeof(T) && sizeof(T) <= 0xFFFFull, int> = 0>
constexpr uint16_t sizeofex() { return sizeof(T); }

template<class T, std::enable_if_t<0xFFFFull < sizeof(T) && sizeof(T) <= 0xFFFFFFFFull, int> = 0>
constexpr uint32_t sizeofex() { return sizeof(T); }

template<class T, std::enable_if_t<0xFFFFFFFFull < sizeof(T), int> = 0>
constexpr uint64_t sizeofex() { return sizeof(T); }

template<class T>
constexpr auto sizeoftype = sizeofex<T>(); // Optional, requires C++14

Usage:

auto bar = sizeofex(var);
auto bar2 = sizeofex<type>();
auto bar3 = sizeoftype<type>; // Requires C++14

sizeoftype has the benefit of being resolvable by IDEs like Visual Studio when you mouse over it.

user_8818140
Related