Question

make C++ functions or structs, classes (using meta-programming) determining maximum value for signed and unsigned type, according to compilers architecture. One for signed and second for unsigned numbers.

Requirements:

• no header files
• self adjusting to variable sizes (no stdint.h)
• no compiler warnings about possible overflow

Clarification:

After comment’s I am surprised, on reaction for non typical C++ problem. I’ve learned it’s good to stress out, that problem is not homework and not from the moon, but it’s practical domain.

For all interested in application of this stuff… first of all: it is not homework :). And it’s practical, answerable question based on actual problems that I face – as in SO.FAQ is suggested . Thanks you for tips about climits etc, but I am looking for “smart piece of code”. For sure climits, limits are well tested and good pieces of code, but they are huge and not necessarily “smart,tricky”. We are looking here for smart solutions (not “huge-any” solutions), aren’t we? Even thou, climits suggestions are ok, as start point. For those interested about area, where including header files is not allowed, and size of source code is relevant, there are few: experiments with compilers, program transformations, preparing problemsets for programming contests, etc. Actually tree of them are relevant to problems I am currently struggling. So I don’t think it’s (SO.FAQ)too localized, and I think, it’s for sure, question for (SO.FAQ)enthusiast programmers. If you think that even all of this, there is something wrong with this question, please let me know – I don’t want to make mistake again. If it’s ok, please let me know, what I could do better to not get it downvoted?

Answer 1

Signedness could be determined at compile-time if you wish to merge maxSigned with maxUnsigned.

#include <iostream>
#include <cstddef> // for pytdiff_t, intptr_t

template <typename T> static inline  bool is_signed() { 
    return ~T(0) < T(1);
}
template <typename T> static inline  T min_value() {
    return is_signed<T>() ? ~T(0) << (sizeof(T)*8-1) : T(0); 
}
template <typename T> static inline  T max_value() { 
    return ~min_value<T>();
}

#define REPORT(type) do{ std::cout\
    << "<" #type "> is " << (is_signed<type>() ? "signed" : "unsigned")\
    << ", with lower limit " << min_value<type>()\
    << " and upper limit " << max_value<type>()\
    << std::endl; }while(false)

int main(int argc, char* argv[]) {
    REPORT(char);  // min, max not numeric
    REPORT(int);
    REPORT(unsigned);
    REPORT(long long);
    REPORT(unsigned long long);
    REPORT(ptrdiff_t);
    REPORT(size_t);
    REPORT(uintptr_t);
    REPORT(intptr_t);
}