#include<iostream>
using namespace std;


//converts from integer hex to char and returns a 4 char array which has 4 digits

char *int_char(short __2byte)
{
	char *_4digit;			//char array to store the result and return
	_4digit = new char[5];	//assign 5 spaces, 4 for digits and 5th for null char
	char *lookup = "0123456789abcdef";	//lookup table stores the hex digits into their
										//corresponding index. ingenious!

	char mask = 0x000f;					//mask will clear out(turn to 0) all the bits except lowest 4
										//which represent a single hex digit

	short temp = __2byte;				//temporary integer placeholder
	temp &= mask;						//mask the integer so it will only have lowest 4 bits

	_4digit[3]=lookup[temp];			//temp now contains a numeric value which will point
										//to the corresponding index in the look up table so
										//all we ahve to do is use it as an index to the lookup
										//array and voila!!! did i mention it's ingenious?
										//now that we have the lowest 4 bits, which makes up
										//the rightmost or the 4th hex digit, we store it in 
										//the 4th slot in our char array

	temp = __2byte;						//assign our entire integer to temp again!
	temp >>= 4;							//this time we are shifting 4 bits to the right
										//so that it will push off the lowest 4 bits and the
										//4 bits to the right of the lowest 4 bits will take their
										//place, since we are already done converting the original
										//lowest 4 bits (single rightmost hex digit)
	temp &= mask;						//now again we mask the integer so that it only contains
										//the lowest 4 bits!
	_4digit[2]=lookup[temp];			//temp will again be an index to the look up array and
										//fetch us our hex digit and this time we assign it to
										//the 3rd slot in our array(counting from left).
										//so now our array has the rightmost 2 hex digits
										//we still need to do 2 more, so we repeat the code!
	temp = __2byte;						//assign the entire integer to temp again
	temp >>= 8;							//this time shift 8 bits! so we will push off lowest
										//8 bits and the 4 bits to the right will take their place
	temp &= mask;						//mask it again
	_4digit[1]=lookup[temp];			//look it up and assign it to the 2nd slot in our array
										//we now have 3 digits done, now just one more!
	temp = __2byte;						//assignment
	temp >>= 12;						//shift 12 bits this time, so the 4 leftmost or highest
										//get pushed off in the place of 4 rightmost or lowest
										//bits
	temp &= mask;						//mask it again
	_4digit[0]=lookup[temp];			//fetch the digit and assign it in the 1st slot!
	
	_4digit[4]='\0';					//assign null to the last char to symbolize the end of string
	return _4digit;						//return our char array!
}	

int main()
{
	short _2byte = 0x4fc2;
	cout<<int_char(_2byte);

	return 0;
}

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

string int2string(const int i)
{
  ostringstream stream;
  stream << i;
  return stream.str();
}

int main(int argc, char *argv[])
{
  int foo = 123;
  string bar = int2string(foo);
  cout << bar << endl;
}