Let's talk about datatypes

So, this morning, I wrote a simple program to sate my curiosity (Such is all hacking) about something I'd never bothered to find out -- just how big is the memory allocated to the datatypes we use everyday?

Code:

#include <stdio.h>
#include <stdlib.h>

int main()
{
  int i;

  i = sizeof(char);
  
  printf( "A char is this big: |" );
  while( i > 0)
    {
      printf( "-" );
      --i;
    }
  printf( "|\n" );
  
  i = sizeof(int);
  
  printf( "An int is this big: |" );
  while( i > 0)
    {
      printf( "-" );
      --i;
    }
  printf( "|\n" );
  
  i = sizeof(short);
  
  printf( "A short is this big: |" );
  while( i > 0)
    {
      printf( "-" );
      --i;
    }
  printf( "|\n" );
  
  i = sizeof(long);
  
  printf( "A long is this big: |" );
  while( i > 0)
    {
      printf( "-" );
      --i;
    }
  printf( "|\n" );
  
  return 0;
}

I know the code seriously needs refactoring, and it could be cleaned up so much, but I just wanted a quick solution.

The answer you'll get depends on platform, but in mine... int is as big as long!! The horror! The bloat!

 

That's because with your compiler (and mine) integers and longs are able to take on the same values (-2147483648 to 2147483647). The more common integer we're used to (-32768 to 32767) is changed to be called short int.

 

That's so redundant, lol. How does I changed long to 8 bytes?

 

__int64?

 

Yup, int = long.

I at least prefer this to VB making Integer = Short. So I always accidentally use Integer instead of Long. Or I used to at least, I don't use VB much these days.

I know how to do 64bit math with 32bit registers. At least I used to... it's all kind of blurry... I haven't used asm in like a year. :'(

 

I actually wrote some code very similar to that when discussing it on a textboard, but my code produces a nice pretty (almost) graphical representation of it (And could still be improved and refactored).