Cross-platform C++ determining maximim integer value (no headers) - c++

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

Under reasonable assumptions for two's complement representation:
template<typename T> struct maxval;
template<> struct maxval<unsigned char>
{
static const unsigned char value = (unsigned char) ~0;
};
template<> struct maxval<signed char>
{
static const signed char value = ((unsigned char) ~0) >> 1;
};
template<> struct maxval<unsigned short>
{
static const unsigned short value = (unsigned short) ~0;
};
template<> struct maxval<short>
{
static const short value = ((unsigned short) ~0) >> 1;
};
int
main ()
{
std::cout << (int)maxval<signed char>::value << std::endl;
}
Likewise for the rest of the types.
Need to distinguish between signed and unsigned types when determining the max value. The easy way is to enumerate all of them like in the above example.
Perhaps it can be done with a combination of enable_if and std::is_unsigned, but reimplementing them (no headers!) will still require enumerating all types.

Answer 2

For unsigned types, it's simple: T(-1) will always be the maximum for that type (-1 is reduced modulo the maximum to fit in the range, always giving the maximum for the type).
For signed integer types, the job is almost as easy, at least in practice: take the maximum unsigned value, shift right one bit, and cast to signed. For C99 or C++11 that will work because only three representations for integers (1's complement, signed magnitude and 2's complement) are allowed (and it gives the correct result for all three). In theory, for C89/90 and/or C++98/03, it might be possible to design a conforming signed type for which it would fail (e.g., a biased representation where the bias was not range/2).
For those, and for floating point types (which have no unsigned counterparts), the job is rather more difficult. There's a reason these are provided in a header instead of being left for you to compute on your own...
Edit: As far as how to implement this for in C++, most of the difficulty is in specializing a template for an unsigned type. The most obvious way to do that is probably to use SFINAE, with an expression that will only be legal for a signed type (or only for an unsigned type). The usual for that would be an array whose size is something like T()-1>0. This will yield false for a signed type, which will convert to 0; since you can't create a zero-sized array, that attempted substitution will fail. For an unsigned type, the -1 will "wrap" to the maximum value, so it would create a size of 1, which is allowed.
Since this seems to be homework, I'm not going to show an actual, working implementation for that though.

Answer 3

This works for unsigned types:
template <typename t>
constexpr t max_val() { // constexpr c++11 thing, you can remove it for c++03
return ~(t(0));
}
signed can't be portably found as you can't assume the number of bits and encoding.

Answer 4

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);
}

Answer 5

Here is my answer, due to the fact, I was not expecting either: enumerating all types (as Chill), either overflow (as I stated -> I don't want compilers warnings); as some of previous answers consisted. Here is what I've found.
As Pubby has shown, unsigned case is simple:
template <class T>
T maxUnsigned(){ return ~T(0); }
As Chill mentioned :
Under reasonable assumptions for two's complement representation
Here is my meta-programming solution for signed case: (metaprogramming is for omitting overflow compiler warnings)
template<class T, int N> struct SignedMax {
const static T value = (T(1)<<N) + SignedMax<T, N - 1>::value;
};
template<class T> struct SignedMax<T, 0> {
const static T value = 1;
};
template<class T>
T maxSigned(){
return SignedMax<T, sizeof(T)*8-2>::value;
}
End example of stuff working
#include <iostream>
using std::cout;
using std::endl;
//(...)
#define PSIGNED(T) std::cout << #T "\t" << maxSigned<T>() << std::endl
int main(){
cout << maxSigned<short int>() << endl;
cout << maxSigned<int>() << endl;
cout << maxSigned<long long>() << endl;
cout << maxUnsigned<unsigned short int>() << endl;
cout << maxUnsigned<unsigned int>() << endl;
cout << maxUnsigned<unsigned long long>() << endl;
return 0;
}