二进制
二进制的基数是2，进位规则是“逢二进一”，借位规则是“借一当二”
八进制
八进制，一种以8为基数的计数法，采用0、1、2、3、4、5、6、7八个数字，“逢八进一”，一些编程语言中常常以数字0开始表明该数字是八进制
十进制
十进制是以10为基础数字系统，是世界上应用最广泛的进位制
十六进制
十六进制是一种“逢十六进一”的进位制，一般用数字0~9和字母A到F（或a到f）表示，其中A到F表示10-15
下面举例说明它们之间的转换


二进制转八进制

以11001010为例

首先自右向左补全（每3个二进制数划分为一个区域）：011 001 010

计算：

011:0* 2^2+1* 2^1+1 *2^0=3

001:0 *2^2+0 *2^1+1 *2^0=1

010:0 *2^2+1 *2^1+0 *2^0=2

最后11001010转换成八进制的结果就是312


二进制转十进制

以11001010为例

只需要把二进制数按权展开相加即是十进制数

计算：

1*2^7+1 *2^6+0 *2^5+0 *2^4+1 *2^3+0 *2^2+1 *2^1+0 *2^0=202

最后11001010转换成十进制的结果就是202


二进制转十六进制

以110010100为例

与二进制转八进制相似，区别在于补全时十六进制是四位补全：0001 1001 0100

计算：

0001:0 *2^3+0 * 2^2+0 * 2^1+1 * 2^0=1

1001:1 * 2^3+0 * 2^2+0 * 2^1+1  * 2^0=9

0100:0 * 2^3+1 * 2^2+0 * 2^1+0 * 2^0=4

最后110010100转换成十六进制的结果就是194


八进制转二进制

以202为例

分别对2、0、2进行求余运算结果为10、0、10，然后把这三个数从左往右补全：010 000 010

最后202转换成二进制结果就是10000010


八进制转十进制

以226为例

从右向左依次乘以8的n次幂（n从0开始）

计算：

2*8^2+2 *8^1+6 *8^0=150

最后226转换成十进制结果就是150


八进制转十六进制

以202为例

先将把八进制转成二进制为10000010，再将1000 0010转成十六进制

计算：

1000：1*2^3+0 *2^2+0 *2^1+0 *2^0=8

0010:  0 *2^3+0 *2^2+1 *2^1+0 *2^0=2

最后202转换成十六进制结果就是82


十进制转二进制

以202为例

对202进行求余运算，结果由下到上读取：11001010



最后202转换成十六进制结果就是11001010


十进制转八进制

以150为例

对150进行求余计算

计算：

150/8=18……6

18/8=2……2

2/8=0……2

最后150转换成八进制结果就是226


十进制转十六进制

以150为例

对150进行求余运算

计算：

150/16=9……6

9/16=0……9

最后150转换成十六进制结果就是96


十六进制转二进制

以12C为例

分别对1、2、C进行求余

计算：

1：  1/2=0……1

2:   2/2=1……0

1/2=0……1

C（12）：12/2=6……0

6/2=3……0

3/2=1……1

1/2=0……1

整合：000100101100

最后12C转换成二进制的结果就是100101100


十六进制转八进制

要先把十六进制转成二进制，再转成八进制或者先把十六进制转成十进制，再转成八进制，转换过程同上


十六进制转十进制

以CA为例

计算：

12*16^1+10 *16^0=202

最后CA转换成十进制的结果就是202

二进制转换我们应该都不会陌生，在二进制，八进制，十六进制之间相互转换在底层应用中，加密的算法中，还是需要我们掌握的。这次进制的转换思想：辗转相除法。将十进制的数字辗转相除所需要转换的数值直到结果为0，将余数倒过来排序即可得到所需要的与原来数值等值的某进制数值。 

比如：100转换为2进制 

100/2=50   余数0 

50/2=25  余数0 

25/2=12  余数1 

12/2=6  余数0 

6/2=3  余数0 

3/2=1 余数1 

1/2=0（结果为0，结束相除） 余数1 

所以100用二进制表示就是：1100100 

假如我们用数组来存储所得到的余数，那么我们在进行结果输出的时候将变锝比较麻烦，因为我们需要从数组存储的余数的最后一位开始输出，要这样做，我们就必须要知道我们的辗转相除结果得到了多少位余数，然后确定数组的下标，从该下标开始倒序输出得到我们需要的结果。 

这时，我们的栈的优良型就凸显出来了，因为我们的栈有元素后进先出的特点，那么我们就只需把相除得到的余数入栈，需要输出结果时出栈就可以了，有木有觉得很方便咧 

下面，就来一起完成吧！

栈的类模板：



#pragma once
#include<iostream>
using namespace std;

const int MaxSize = 100;   //数组最大值

template<typename T>
class Stack {
public:
    Stack();     //构造函数
    ~Stack();   //析构函数
    bool Empty();    //判空
    bool Full();    //判满
    bool EnStack(T x);    //入栈
    bool pop();     //出栈
    bool GetTop(T &element);    //获取栈顶元素
private:
    T data[MaxSize];   顺序栈的数组
    int top;
};

template<typename T>
Stack<T>::Stack() {
    top = -1;
}
template<typename T>
Stack<T>::~Stack() {

}
template<typename T>
bool Stack<T>::Empty() {   //栈判空
    return top == -1 ? true : false;
}
template<typename T>
bool Stack<T>::Full() {   //栈判满
    return top == MaxSize - 1 ? true : false;
}
template<typename T>
bool Stack<T>::EnStack(T x) {    //元素进栈
    if (Full()) {
        return false;
    }
    top++;
    data[top] = x;
    return true;
}
template<typename T>
bool Stack<T>::pop() {   //元素出栈
    if (Empty()) {
        return false;
    }
    top--;
    return true;
}
template<typename T>
bool Stack<T>::GetTop(T &element) {  查看栈顶元素
    if (!Empty()) {
        element = data[top];
        return true;
    }
    return false;
}

二进制的转换简单法及简单测试：

#include<iostream>
#include"Stack.h"
using namespace std;

/********栈的应用：进制的转换  ***********/
/********原理：进制转换的时候利用辗转相除法，依次将取余所得的数字
                然后需要取出来的时候就从栈顶中一个个取出来   
                取出来的时候就刚好是顺序了       

********/

#define  binary         2   //转换成2进制
#define  OCTONARY       8   //转换成8进制
#define  HEXADECTMAL   16   //转换成16进制

int main() {
    char num []= "0123456789ABCDEF";      //为适应16进制的转换
    Stack<int>  *p = new Stack<int>;
    int N = 2017;     //待转换的数字
    int mod = 0;      //中间值
    while (N!=0) {    //余数进栈
        mod = N%binary;     //获得余数
        p->EnStack(mod);   //余数进栈
        N = N / binary;    //获得下一次的被除数
    }
    int elem=0;       //取出栈顶元素的中间值
    while (!p->Empty()) {
        p->GetTop(elem);
        p->pop();
        cout << num[elem];
    }

    delete p;    //归还空间
    p = NULL;   //归还空间
    return 0;
}

调用结果：（2017转换位二进制） 


就这样，我们就利用栈实现了一个比数组实现方法简单的二进制转换的小例子。 

有一点要说的是，这里我们用的是顺序栈来实现的，当然我们也可以用链栈来实现（看具体环境的需要吧）

以上所说的难免有错漏，如有错误，还望不吝赐教，及时指出，谢谢

例一：数制转换


	算法基于原理：
	N = (N div d) * d + N mod d
	十进制转化为八进制数：除八取余;
	十进制转化为二进制数：除二取余;

	B ：二进制数。 Q ：八进制数。 D ：十进制数。 H ：十六进制数。
	例如：(1348)D = (2504)Q
	运算过程：(商为0时结束)
	  N       N div 8       N mod 8
	  1348      168          4
	  168        21            0
	  21          2             5
	  2            0             2
	
	void conversion(){
		InitStack(&S);
		scanf("%d", N);
		while(N){
			Push(S, N % 8);
			N = N / 8;
		}
		while(!StackEmpty(S)){
			Pop(S, e);
			printf("%d", e);
		}
	}//conversion

	例二：括号匹配的检验

	假设在表达式中
	( [ ] ( ) )  、 [ ( [ ] [ ] ) ] 等为正确的格式。
	{ ( } )   、 ( [ ) ]等为错误的格式。
	则检验括号是否匹配的方法可用"期待的紧迫程度"这个概念来描述。
	算法的设计思想：
		1、凡是出现左括号，则进栈;
		2、凡是出现右括号，首先检查栈是否为空; 若栈空，则表明该"右括号"多余，
		否则和栈顶元素比较：
			若相匹配，则"左括号"出栈;
			否则表明不匹配;
		3、表达式检验结束时：
			若栈空，则表明表达式中匹配正确。
			否则表明"左括号"有余。
	算法描述：
	void match(char *exp){
		InitStack(&S);
		char c;
		int i = 0, b = 1;
		while(exp[i] != '\0' && b == 1){
			if(exp[i] == '(')
				push(S, exp[i]);
			else if(exp[i] == ')'){
				c = Pop(S);
				if(c != '(')
					b = 0;
			}
			i++
		}
		return (b && StackEmpty(S));
	} 

	例三：行编辑程序问题

	在用户输入一行的过程中，允许用户输入出差错，并在发现有误时可以及时更正。
	合理的做法是：
	设立一个输入缓冲区，用以接受用户输入的一行字符，然后逐行存入用户数据区;
	并假设"#"为退格符，"@"退行符。

	例如：从终端输入两行字符：
		whli##ilr#e(s#*s)
			outcha@putchar(*s=#++);
		则实际有效的下列两行：
		while(*s)
			putchar(*s++);


	算法描述：
		while(ch != EOF && ch != '\n'){
			switch(ch){
				case '#': Pop(&S, e); break;
				case '@': ClearStack(&S); break;//重置S为空栈
				default: Push(S, ch); break;
			}
			ch = getchar(); //从接收端接受下一个字符。
		}


	例四：表达式求值


	限于二元运算符的表达式定义：
	表达式 = (操作数) + (运算符) + (操作数)
	操作数 = 简单变量|表达式
	简单变量 = 标识符|无符号整数


	表达式的三种标识方法：
	设Exp = S1 + OP + S2
	则称 OP + S1 + S2 为 前缀表达式
	     S1 + OP + S2 为 中缀表达式
	     S1 + S2 + OP 为 后缀表达式


	例如： Exp = a * b + (c - d / e) * f
	 前缀式：+ * a b * - c / d e f
	 中缀式：a * b + c - d / e * f
	 后缀式：a b * c d e / - f * +
	结论： 1、操作数之间的相对次序数不变;(a, b, c, d, e, f)
	           2、运算符的相对次序不同;
	           3、中缀式丢失了括弧信息，致使运算的次序不确定;
	           4、前缀式的运算规则为：
		   连续出现的两个操作数和在它们之前且紧靠它们的运算符构成一个最小表达式;
	           5、后缀式的运算规则为：
	           运算符在式中出现的顺序恰为表达式的运算顺序;
		   每个运算符和在它之前出现且紧靠它的两个操作数构成一个最小表达式;


	****如何从后缀式求值？****
		先找运算符，再找操作数。(运算符之前的两个操作数)
		例如：a b * c d e / - f * +
	****如何从原表达式求得后缀式？****
		分析"原表达式"和"后缀式"中的运算符：
		原表达式：a + b * c - d / e * f
		后缀式：  a b c * + d e / f * -
		从原表达式求得后缀式的规律为：
		1. 设立暂存运算符的栈;
		2. 设表达式的结束符为"#"，予设运算符的栈底为"#";
		3. 若当前字符是操作数，则直接发送给后缀式;
		4. 若当前运算符的优先数高于栈顶运算符，则进栈;
		5. 否则，推出栈顶运算符发送给后缀式;
		6. "("对它之前的运算符起隔离作用，")"可视为自相应左括弧开始的表达式的结束符;


	例五：实现递归


	当在一个函数的运行期间调用另一个函数时，在运行该被调用函数之前，
	需要完成三项任务:
	*将所有的实际参数、返回地址等信息传递给被调用函数保存;
	*为被调用函数的局部变量分配存储区;
	*将控制转移到被调用函数的入口;


	从被调用函数返回调用函数之前，应该完成下列三项任务：
	*保存被调函数的计算结果;
	*释放被调函数的数据区;
	*依照被调函数保存的返回地址将控制转移到调用函数。


	多个函数嵌套调用的规则是：
		后调用先返回！
	此时内存管理实行"栈式管理"

引言

在做数据读写传输时最常用也最直观的莫过于十进制数，但是在不同应用场合、存储的方便在C语言开发时候也常采用二进制、八进制和十六进制存储数据。这边博文将对这3种进制转十进制及十进制转这3种进制做一解释并举例。



什么是进制

进制是一种计数机制，对于任何一种进制，如：x进制，就表示某一位置上的数运算时逢 x 进一位。例如：时间60′，分钟就会加 1，这就是六十进制。计算机中常用的进制有二进制、八进制、十进制、十六进制。下面将分别举例介绍这些进制及转换十进制的方法和十进制分别这几种进制的方式。



位值计数法

位值制记数法，一种利用位值制记数的方法。位值制即每个数码所表示的数值，不仅取决于这个数码本身，而且取决于它在记数中所处的位置。

x进制整数an−1⋯a3a2a1a0转换十进制整数过程： 
x进制采用位置计数法，位权是x为底的幂。对于n位整数，x进制数用加权系数的形式表示如下： 
a0×x0+a1×x1+a2×x2+a3×x3+⋯+an−1×xn−1


十进制的整数a0转换x进制的整数过程： 

为了叙述方便，x进制的数据从左到右，分别记作第一位，第二位⋯,int为取整。 

第一位：a0%x
a1=int(a0/x)

第二位：a1%x
a2=int(a1/x)

第三位：a2%x
⋯
下面不同进制之间的转换将按照位值计数法进行转换。



二进制

二进制是一种“逢二进一”的进制制，它用 0 和 1 两个符号来描述。在自然界中大多数事物都存在可用0和1表示的相对立的二个状态。在计算机中正是利用了这一特点，采用电位的高低、脉冲的有无、二极管的截止与导通、纸带上有孔无孔等来表示0、1这两个状态。

二进制转十进制： 

二进制数字：10101011

十进制数字： 
1×20+1×21+0×22+1×23+0×24+1×25+0×26+1×27=1+2+0+8+0+32+0+128=171

十进制转二进制： 

十进制数字：171 

二进制数字： 

第一位：171%2=1
int(171/2)=85

第二位：85%2=1
int(85/2)=42

第三位：42%2=0
int(42/2)=21
⋯

最后计算得二进制数字：10101011

用二进制表示一个数所使用的位数要比十进制、八进制、十六进制等表示时使用的位数长得多，书写起来不方便，也不好读，这是二进制的缺陷。为此，人们通常使用八进制、十六进制来作为二进制的缩写方式。

八进制

八进制，Octal，缩写OCT或O，一种以8为基数的计数法，采用0，1，2，3，4，5，6，7八个数字，逢八进1。一些编程语言中常常以数字0开始表明该数字是八进制。

八进制转十进制： 

八进制数字：127 

十进制数字： 
7×80+2×81+1×82=7+16+64=87

十进制转八进制： 

十进制数字：87 

八进制数字： 

第一位：87%8=7
int(87/8)=10

第二位：10%8=2
int(10/8)=1

第三位：1%8=1

因此得十进制数：127

十六进制

十六进制，Hexadecimal，它由0-9，A-F组成，字母不区分大小写。与10进制的对应关系是：0-9对应0-9；A-F对应10-15。

十六进制转十进制 

十六进制数字：0x7fff 

十进制数字： 
15×160+15×161+15×162+7×163=15+240+3840+28672=32767

十进制转十六进制 

十进制数字：32767 

十六进制数字： 

第一位：32767%16=f
32767/16=2047

第二位：2047%16=f
⋯

计算得16进制数字：7fff

提示C++源码中定义随机数最大值为十六进制的7fff：

/* Maximum value that can be returned by the rand function. */

#define RAND_MAX 0x7fff

总结

这里只涉及了正整数的多种进制的互相转换，后面会不断完善小数及负数的多种进制的互相转换。

参考


  
http://baike.baidu.com/link?url=x7cKB5xnH5J63iDQV0iyFJhV2HfwcG5nXnT8eVKeUlj5Hg2gTcqpc4vOtO21YVg3EzWxc7AtgTLBICVSiTGrD8gLACDtqAWCRNDl-3zTVpmyJNOn-q3LNpK_1eKq8p3YxxrdWNdsUI9ELUpLZOhvha 
http://www.cnblogs.com/junsky/archive/2009/08/06/1540727.html 
https://baijiahao.baidu.com/po/feed/share?wfr=spider&for=pc&context=%7B%22sourceFrom%22%3A%22bjh%22%2C%22nid%22%3A%22news_4426951029281816189%22%7D 
http://baike.baidu.com/link?url=MZO5oSW-4UVEAnL6BouXuaCXvWWwlxgEL1mKsrUj_mbNi0wd2SEWrX7k-SNM3PmumaEiG97M_wU40JC8sQ229Cmm3j1XyD0omVLypIkZ4yseE5xnLOtvodNWS4TvSgM1 
http://baike.baidu.com/link?url=lFnhGNtMxFhOhO-8erD44UyykbXzu1M53-zWLgZGu5gn-PZWj3vZzQRyMubzbGuQEn1MVTKJ2k_lLEZnH1SXhbZyJpALiz_xhoJmRREzmvx6xySuyNQjuLfzGL8fG_Aa