C++ Berechnen der größt möglichen Werte eines Datentyps

include <iostream>

using namespace std;

void Main()
{
	short ssh = 0;
	cout << "groesster Shortint mit VZ: " << ~ssh << "\n";
	unsigned short ush = 0;
	cout << "groesster Shortint ohne VZ: " << ~ush << "\n";
	long sl = 0;
	cout << "groesster Longint mit VZ: " << ~sl << "\n";
	unsigned long ul = 0;
	cout << "groesster Longint ohne VZ: " << ~ul << "\n";
}

#include <iostream>
#include <limits.h>

int main(void)
{
	int i=0;
	int j;
	for(;;)
	{
		j=i;
		i++;		
		if(i<j)
		{
			std::cout << "Max int (counted) is: " << j;
			std::cout << std::endl;
			std::cout << "Max int is (limits.h): " << INT_MAX;
			break;
		}
	}
	return 0; //Hier Breakpoint setzen...
}

tmp=1;

max=tmp;
while (tmp >0){
   max += tmp;
   tmp *= 2;
}
min = tmp;

ush = ~ush;

#include "stdafx.h"
#include <conio.h>
#include <stdio.h>

// zeigt nBytes an der Adresse p an
// bReverseBytes dreht die Reihenfolge um, damit
// die Zahl auf LittleEndian-Systemen lesbar ist
void printMem(void *p, int nBytes, bool bReverseBytes) {
	unsigned char ucByte;
	int iIndex;

	for(int i=0; i<nBytes; i++) {
		iIndex = bReverseBytes ? (nBytes-1-i) : i;

		ucByte = ((unsigned char*)p)[iIndex];
		printf("0x%02x ", ucByte);
	}
	printf("\n");
}

int main(int argc, char* argv[])
{
	unsigned int imaxpos1, imaxpos2, imaxpos3, imaxpos4;
	signed int imaxpossigned, imaxnegsigned;

	// erstmal die Datentypbreiten ausgeben:
	printf("Datentypbreiten:\nChar: %u\nShort %u\nInt %u\nLong %u\n\n", sizeof(char), sizeof(short), sizeof(int), sizeof(long));

	// das hier funktioniert zwar, ist aber falsch, weil die 1 innerhalb der Klammer ein int ist,
	// und mit einem Shift um 32 Bits aus dem Datentyp rausgeschoben wird; die Rechnung lautet
	// daher dann 0 - 1
	imaxpos1 = (1 << 32) - 1;

	// hier wird der unsigned int im zweiten Fall automatisch als signed interpretiert
	// wie man sieht liefern alle vier das gleiche Ergebnis
	printf("imaxpos1 unsigned: %u signed: %i\n", imaxpos1, imaxpos1);

	// hier der Beweis
	printf("(1 << 32) = %u\n", (unsigned int)(1<<32) );	

	// daher funktioniert auch das
	imaxpos2 = (unsigned int) -1;
	printf("imaxpos2 unsigned: %u signed: %i\n", imaxpos2, imaxpos2);

	// richtigerweise müsste man intern mit einem breiteren Datentyp rechnen
	// 1ul bedeutet, dass die 1 ein unsigned long-wert ist; die Rechnung in der Klammer also
	// mit einem unsigned long gerechnet wird.
	// Problem: long und int sind hier gleich breit, es passiert also das gleiche wie zuvor!
	imaxpos3 = (unsigned int)((1ul << 32) - 1);
	printf("imaxpos3 unsigned: %u signed: %i\n", imaxpos3, imaxpos3);

	// ... wie man hier sieht:
	unsigned long ltemp = (1l << 32);
	printf("((unsigned long)(1 << 32) = %u\n", ltemp);
	ltemp = ltemp-1;
	imaxpos4 = (unsigned int)ltemp;		
	printf("imaxpos4 unsigned: %u signed: %i\n", imaxpos4, imaxpos4);

	printf("\nSigned Typen:\n");

	// Rechnung mit signed
	imaxpossigned = (signed int)( ((unsigned int)1 << 31) - 1 );
	imaxnegsigned = -(imaxpossigned+1);

	printf("imaxpossigned unsigned: %u signed: %i\n", imaxpossigned, imaxpossigned);
	printf("imaxnegsigned unsigned: %u signed: %i\n", imaxnegsigned, imaxnegsigned);

	// Speicherbereich der Variablen in Hex
	printf("\nSpeicherbereiche:\n");
	printf("imaxpos1:      "); printMem(&imaxpos1, 4, true);
	printf("imaxpossigned: "); printMem(&imaxpossigned, 4, true);
	printf("imaxnegsigned: "); printMem(&imaxnegsigned, 4, true);

	_getch();
	return 0;
}

Datentypbreiten:
Char: 1
Short 2
Int 4
Long 4

imaxpos1 unsigned: 4294967295 signed: -1
(1 << 32) = 0
imaxpos2 unsigned: 4294967295 signed: -1
imaxpos3 unsigned: 4294967295 signed: -1
((unsigned long)(1 << 32) = 0
imaxpos4 unsigned: 4294967295 signed: -1

Signed Typen:
imaxpossigned unsigned: 2147483647 signed: 2147483647
imaxnegsigned unsigned: 2147483648 signed: -2147483648

Speicherbereiche:
imaxpos1:      0xff 0xff 0xff 0xff
imaxpossigned: 0x7f 0xff 0xff 0xff
imaxnegsigned: 0x80 0x00 0x00 0x00

char x = 'a';
cout << x << endl;
cout << +x << endl;

long sl = 0;	
while ((sl+1) >= 0)
{
	sl <<= 1;
	sl++;
}
std::cout << "Größter long Int: " << sl << "\n";