a hobbyist here so sorry for the nooby question. K&R ex. 2-1. Use header constants and/or direct computation to calculate range of various variable types (char, short, int, long) + floating types. I used limits.h constants to print the range of fixed width variable types for reference. And I still have to check IEEE754.
My max functions gives me 1 less for the desired result, like: 0xfe, 0xfffe, etc so the LSB for some reason is not toggled to 1. Why is that? Yesterday, while thinking on the problem, I came up with the idea to use void* type to pass the various variable types to min-max functions. To be able to derefence void* type storing addresses of fixed width numbers with different length, I had the idea to simply cast it to size_t* type, and somehow it works, and I don't know why. Is this even legal, I've never seen it in my C programming books. If it is not legal, what other possibilites does one have to derefence void* type?
I do not wish to use loops and check overflows, that method is very slow.
#include <stdio.h>
#include <float.h>
#include <limits.h>
void unsigned_max(void* data_ptr, size_t data_size) {
int bit = ((int)data_size * 8) - 1;
while(bit) {
*(size_t*)data_ptr |= 1 << bit;
bit--;
}
}
void unsigned_min(void* data_ptr, size_t data_size) {
int bit = ((int)data_size * 8) - 1;
while(bit){
*(size_t*)data_ptr &= 0 << bit;
bit--;
}
}
void signed_min(void* data_ptr, size_t data_size) {
int bit = ((int)data_size * 8) - 1;
*(size_t*)data_ptr |= 1 << bit;
bit--;
while (bit) {
*(size_t*)data_ptr |= 0 << bit;
bit--;
}
}
void signed_max(void* data_ptr, size_t data_size) {
int bit = ((int)data_size * 8) - 1;
*(size_t*)data_ptr &= 0 << bit;
bit--;
while (bit) {
*(size_t*)data_ptr |= 1 << bit;
bit--;
}
}
int main(void) {
unsigned char u_byte = 0;
char byte = 0;
unsigned short ushort_intgr = 0;
short short_intgr = 0;
unsigned int u_intgr = 0;
int intgr = 0;
unsigned long ulong_intgr = 0;
long long_intgr = 0;
char str_output[18] = "Min-max range of";
char delimiter[18] = "================";
/*
* Print ranges of unsigned and signed instances of char, short, int and long
* variables using limits.h constants.
*/
printf("%s unsigned char:\n%x,%x\n", str_output, u_byte, UCHAR_MAX);
printf("%s signed char:\n%x,%x\n", str_output, CHAR_MIN, CHAR_MAX);
printf("%s unsigned short:\n%x,%x\n", str_output, ushort_intgr, USHRT_MAX);
printf("%s signed short:\n%x,%x\n", str_output, SHRT_MIN, SHRT_MAX);
printf("%s unsigned int:\n%x,%x\n", str_output, u_intgr, UINT_MAX);
printf("%s signed int:\n%x,%x\n", str_output, INT_MIN, INT_MAX);
printf("%s unsigned long:\n%x,%x\n", str_output, ulong_intgr, ULONG_MAX);
printf("%s signed long:\n%x,%x\n", str_output, LONG_MIN, LONG_MAX);
printf("%s\n", delimiter);
/*
* Print ranges of unsigned and signed instances of char, short, int and long
* variables using bitwise operations.
*/
printf("%s unsigned char:\n%d,", str_output, u_byte);
unsigned_max(&u_byte, sizeof(u_byte));
printf("%x\n", u_byte);
printf("%s signed char:\n", str_output);
signed_min(&u_byte, sizeof(u_byte));
printf("%x,", u_byte);
signed_max(&u_byte, sizeof(u_byte));
printf("%x\n", u_byte);
printf("%s unsigned short:\n%d,", str_output, ushort_intgr);
unsigned_max(&ushort_intgr, sizeof(ushort_intgr));
printf("%x\n", ushort_intgr);
printf("%s signed short:\n", str_output);
signed_min(&short_intgr, sizeof(short_intgr));
printf("%x,", short_intgr);
signed_max(&short_intgr, sizeof(short_intgr));
printf("%x\n", short_intgr);
printf("%s unsigned int:\n%u,", str_output, u_intgr);
unsigned_max(&u_intgr, sizeof(u_intgr));
printf("%x\n", u_intgr);
printf("%s signed int:\n", str_output);
signed_min(&intgr, sizeof(intgr));
printf("%x,", intgr);
signed_max(&intgr, sizeof(intgr));
printf("%x\n", intgr);
printf("%s unsigned long:\n%lu,", str_output, ulong_intgr);
unsigned_max(&ulong_intgr, sizeof(ulong_intgr));
printf("%x\n", ulong_intgr);
printf("%s signed long:\n", str_output);
signed_min(&long_intgr, sizeof(long_intgr));
printf("%x,", long_intgr);
signed_max(&long_intgr, sizeof(long_intgr));
printf("%x\n", long_intgr);
return 0;
}
My output is:
Min-max range of unsigned char:
0,ff
Min-max range of signed char:
ffffff80,7f
Min-max range of unsigned short:
0,ffff
Min-max range of signed short:
ffff8000,7fff
Min-max range of unsigned int:
0,ffffffff
Min-max range of signed int:
80000000,7fffffff
Min-max range of unsigned long:
0,ffffffff
Min-max range of signed long:
80000000,7fffffff
================
Min-max range of unsigned char:
0,fe
Min-max range of signed char:
fe,7e
Min-max range of unsigned short:
0,fffe
Min-max range of signed short:
ffff8000,7ffe
Min-max range of unsigned int:
0,fffffffe
Min-max range of signed int:
80000000,7ffffffe
Min-max range of unsigned long:
0,fffffffe
Min-max range of signed long:
80000000,7ffffffe
I also looked at the K&R solution book, the writers solve usually everything with elegant one-liners. It doesn't seem to work when I run it, giving back zeroes for min and max values. I know that -0 is every bit is true in one's complement form. That time -0 could have been stored as 0x1111? So 0x1111 >> 1 = 0x0111; 0x0111*(-1) = 0x1000?
printf("signed char min = %d\n", -(char)((unsigned char) -0 >> 1));
printf("signed char max = %d\n", (char)((unsigned char) -0 >> 1));
printf("unsigned char max = %u\n", (unsigned char) -0);
...
