C++实现二进制、八进制、十进制、十六进制的相互转换

为了练手，也为了回顾C++基础，最近将坚持写一些小程序贴出来，做记录的同时也希望能对他人有帮助。

用C++实现的各进制之间的转换程序

各进制特点省略，只关注与怎样实现转换。其实网上有很多进制转换的应用，这里也就自己写着玩罢了。

1 十进制数换算成二进制、八进制、十六进制数

将一个十进制数转换为二进制、八进制、十六进制数时，其整数部分和小数部分分别用“除R取余法”和“乘R取整法”转换，然后将结果加小数点三部分合在一起（R为某进制的基数）。

转换规则如下：

·   整数部分：用除R取余法转换。将十进制的整数部分除以R，得到一个商数和余数；再将这个商数除以R，又得到一个商数和余数；反复执行这个过程，直到商为0为止。

       将每次所得的余数从后往前读（先得的余数为低位，后得的余数为高位）即为等值的二进制数。

•   小数部分：用乘R取整法转换。将小数部分乘以R，记下乘积的整数部分，再用余下的纯小数部分乘以R，记下乘积的整数部分；不断重复此过程，直至乘积小数部分为0

             或已满足要求的精度为止。将所得各乘积的整数部分顺序排列（先得的整数为高位，后得的整数为低位）即可。

2  非十进制数转换成十进制数

      位权法：把各非十进制数按权展开，然后求和。

3. 二进制转换为八进制、十六进制

二进制 -> 八进制：将整数部分自右向左和小数部分自左向右分别按每三位为一组（不足三位用0补足），然后将各个三位二进制数转换为对应的一位八进制数。

二进制 -> 十六进制：将整数部分自右向左和小数部分自左向右分别按每四位为一组，不足四位用0补足，然后将各个四位二进制数转换为对应的一位十六进制数。

4. 八进制、十六进制转换为二进制

  八进制 -> 二进制：把每一位八进制数转换为对应的三位二进制数。

      十六八进制 -> 二进制： 把每一位十六进制数转换为对应的四位二进制数。

代码文件如下：

numberConvert.h

/************************************************************************/
/*        本程序旨在实现二进制、八进制、十进制、十六进制之间的相互转换                
/		author: Ray Lei
/		Date: 2014/04/25
*/
/************************************************************************/
#ifndef NUMBERCONVERT_H
#define NUMBERCONVERT_H
#include<string>
using namespace std;
class numberConvert
{
public:
	static string decToBin(double dec, int len=5);
	static string decToOct(double dec, int len=5);
	static string decToHex(double dec, int len=5);
	static string binToDec(string bin);
	static string octToDec(string oct);
	static string hexToDec(string hex);
	static string binToOct(string bin);
	static string binToHex(string bin);
	static string octToBin(string oct);
	static string hexToBin(string hex);
private:
	static string decToR(double dec, int r, int len=5);
	static string rToDec(string sr, int r);
	static string binToR(string bin, int r);
	static string rToBin(string sr, int r);
};
#endif 

numberConvert.cpp

#include "stdafx.h"
#include<iostream>
#include <sstream>
#include<string>
#include<cmath>
#include "numberConvert.h"
using namespace std;

string numberConvert::decToBin(double dec, int len)
{
	return numberConvert::decToR(dec, 2, len);
}

string numberConvert::decToOct(double dec, int len)
{
	return numberConvert::decToR(dec, 8, len);
}

string numberConvert::decToHex(double dec, int len)
{
	return numberConvert::decToR(dec, 16, len);
}

string numberConvert::decToR(double dec, int r, int len/* =5 */)
{
	string sr;
	int ival = (int)dec;
	double d = dec - (double)ival;
	//整数部分
	while (ival != 0)
	{
		stringstream ss;
		ss<<ival %r;
		string s = ss.str();
		if (r==16 && (ival%r >= 10))
		{
			int alu = ival % r;
			switch(alu)
			{
			case 10: s="A"; break;
			case 11: s="B"; break;
			case 12: s="C"; break;
			case 13: s="D"; break;
			case 14: s="E"; break;
			case 15: s="F"; break;
			}		
		}
		sr = s+sr;
		ival = ival/r;
	}

	if(d == 0.0)
		return sr;

	//小数部分
	int n = 0;
	string s=".";
	while (n < len)
	{
		if (d*r >= 1)
		{
			stringstream ss;
			ss<<(int)(d*r);
			string s1 = ss.str();
			if (r==16 && (int)(d*r) >= 10)
			{
				int alu = (int)(d*r);
				switch(alu)
				{
				case 10: s1="A"; break;
				case 11: s1="B"; break;
				case 12: s1="C"; break;
				case 13: s1="D"; break;
				case 14: s1="E"; break;
				case 15: s1="F"; break;
				}		
			}
			s+=s1;
			n++;
			d=d*r-(int)(d*r);
		}
		else
		{
			s+="0";
			n++;
			d = d*r;
		}

		if (d-(int)d == 0)
			break;
	}
	return sr+s;
}

std::string numberConvert::binToDec(string bin)
{
	return numberConvert::rToDec(bin, 2);
}

std::string numberConvert::octToDec(string oct)
{
	return numberConvert::rToDec(oct, 8);
}

std::string numberConvert::hexToDec(string hex)
{
	return numberConvert::rToDec(hex, 16);
}

// 将R进制转换为十进制：把各非十进制数按权展开，然后求和
std::string numberConvert::rToDec(string sr, int r)
{
	string sint, sdec;
	size_t index = sr.find_first_of(".");
	if (index != string::npos)
	{
		sint = sr.substr(0, index);
		sdec = sr.substr(index+1);
	}else{
		sint = sr;
	}

	double sum = 0;
	int len = sint.length();
	for (int i=len-1;i>=0;--i)
	{
		string ch;
		if (r==16 && sint[i] >=10)
		{
			switch(sint[i])
			{
			case 'A': 
			case 'a':
				ch="10"; break;
			case 'B':
			case 'b':
				ch="11"; break;
			case 'C':
			case 'c':
				ch="12"; break;
			case 'D':
			case 'd':
				ch="13"; break;
			case 'E': 
			case 'e':
				ch="14"; break;
			case 'F':
			case 'f':
				ch="15"; break;
			}		
		}
		string s1(1, sint[i]);
		s1 = ch.empty()? s1:ch;
		int n = atoi(s1.c_str());
		sum +=n*pow((double)r, len-1-i);
	}

	if (sdec != "")
	{
		int slen = sdec.length();
		for (int i=0;i<slen;++i)
		{
			string s1(1, sdec[i]);
			int n = atoi(s1.c_str());
			sum+=n*1/(pow((double)r, (i+1)));
		}
	}

	stringstream ss;
	ss<<sum;
	return ss.str();
}

std::string numberConvert::binToOct(string bin)
{
	return binToR(bin, 8);
}

std::string numberConvert::binToHex(string bin)
{
	return binToR(bin, 16);
}

std::string numberConvert::octToBin(string oct)
{
	return rToBin(oct, 8);
}

std::string numberConvert::hexToBin(string hex)
{
	return rToBin(hex, 16);
}

std::string numberConvert::binToR(string bin, int r)
{
	int len = bin.length();
	string sint, sdec;
	size_t index = bin.find_first_of(".");
	if (index != string::npos)
	{
		sint = bin.substr(0, index);
		sdec = bin.substr(index+1);
	}else{
		sint = bin;
	}
	
	string rval;
	if (r==8)
	{
		//整数部分
		int dex = sint.length()-1;
		while(dex-2>=0)
		{
			string s = sint.substr(dex-2, 3);
			rval = numberConvert::binToDec(s) + rval;
			dex = dex -3;
		}
		string s = sint.substr(0, dex+1);
		rval = numberConvert::binToDec(s) + rval;

		//小数部分
		if (!sdec.empty())
		{
			rval += ".";
			int dex = sdec.length();
			int pos=0;
			while (dex>3)
			{
				string s = sdec.substr(pos, 3);
				rval += numberConvert::binToDec(s);
				pos += 3;
				dex = dex - 3;
			}
			string s = sdec.substr(pos);
			while(s.length()<3){
				s += '0';
			}
			rval += numberConvert::binToDec(s);			
		}
	}

	if (r==16)
	{
		//整数部分
		int dex = sint.length()-1;
		while(dex-3>=0)
		{
			string s = sint.substr(dex-3, 4);
			string temp = numberConvert::binToDec(s);
			rval = numberConvert::decToHex(stoi(temp)) + rval;
			dex = dex -4;
		}
		string s = sint.substr(0, dex+1);
		rval = numberConvert::decToHex(stoi(numberConvert::binToDec(s))) + rval;

		//小数部分
		if (!sdec.empty())
		{
			rval += ".";
			int dex = sdec.length();
			int pos=0;
			while (dex>4)
			{
				string s = sdec.substr(pos, 4);
				rval += numberConvert::binToDec(s);
				pos += 4;
				dex = dex - 4;
			}
			string s = sdec.substr(pos);
			while(s.length()<4){
				s += '0';
			}
			rval += numberConvert::binToDec(s);			
		}
	}

	return rval;
}

string numberConvert::rToBin(string sr, int r)
{
	int len = sr.length();
	string sint, sdec;
	size_t index = sr.find_first_of(".");
	if (index != string::npos)
	{
		sint = sr.substr(0, index);
		sdec = sr.substr(index+1);
	}else{
		sint = sr;
	}

	string rval;
	if (8==r)
	{
		int len =sint.length();
		for (int i=0;i<len;++i)
		{
			string s(1, sint[i]);
			string ddec = octToDec(s);
			rval += decToBin(stoi(ddec));
		}

		rval += ".";
		len = sdec.length();
		for (int i=0;i<len;++i)
		{
			string s(1, sdec[i]);
			rval += decToBin(stoi(octToDec(s)));
		}
	}

	if (16==r)
	{
		int len =sint.length();
		for (int i=0;i<len;++i)
		{
			string s(1, sint[i]);
			string ddec = hexToDec(s);
			rval += decToBin(stoi(ddec));
		}

		rval += ".";
		len = sdec.length();
		for (int i=0;i<len;++i)
		{
			string s(1, sdec[i]);
			rval += decToBin(stoi(hexToDec(s)));
		}
	}

	return rval;
}