进制转换（ C++字符数组）

注：

　　　　较为简便的方法是用整型（int）或浮点型（long、double 注意：该类型不一定能够准确存储数据）来存放待转换的数值，可直接取余得到每一位数值

　　　　较为稳定的方法是用字符数组储存待转换的数值，这将能够完整存储数据，但是也相对于代码较长

　　　　进制转换只需要两步： R -> 十或者十 -> R 　　（R表示除十进制的任意进制,10表示十进制）

以下是较为完整的全部代码，若是实现如何转换的，主看：

　　　　void Ten_Other(char[],int,int,char[],int&);

　　　　void Other_Ten(char[],int,int,char[],int&);  
　　　　两个函数的实现

 #include <iostream>

 using namespace std;

 struct Node {

     Node * Next;

     int data;

 };

 class Stack {    // 先进后出，用于存放除得的余数，取栈元素的时候正好于计算的相反，参见 短除法取得的余数的逆序为二进制数

 public:

     Stack();

     ~Stack();

     char GetTop();

     bool Push(char);

     bool Isempty();

     bool Pop();

 private:

     Node * Head;

 };

 class Queue {    //先进先出，用于存放计算获得的每一位上的数值，参见 位权展开法，正序

 public:

     Queue();

     ~Queue();

     char GetTop();

     bool Add(char);

     bool Drop();

     bool Isempty();

 private:

     Node * Head;

     Node * Tail;

 };

 void Ten_Other(char[],int,int,char[],int&);    //数组指针，长度，转换进制 10 ->x    , 目标数组，组长

 void Other_Ten(char[],int,int,char[],int&);    //数组指针，长度，转换进制 x  ->10  , 目标数组，组长

 void Run(char*,int,int,int,char*,int&); //重载数组，长度，当前数组进制，目标进制

 void Show(char[],int);

 void Create(char[],int&);

 int main() {

     bool flag = true;

     const int max = ;

     char Arr[max];        // 作为原始数组 或 目标进制放入该数组中

     int len=max;        // 数组最大字符数据    也同时是目标数组的长度

     while(flag) {

         cout<<"请输入您要转换的进制(以 # 作为结束符)：";

         Create(Arr, len);

         cout<<"请输入您刚输入的进制数和目标进制数:";

         int start, end;

         cin>> start>> end;

         cout<<"进制转换:  ";

         Show(Arr, len);

         Run(Arr, len, start, end, Arr, len);

         cout<<" -> ";

         Show(Arr, len);

         cout<<endl;

         cout<<"输入0 结束， 输入1 继续: " ;

         cin>> flag;

     }

     delete[] Arr;

     return ;

 }

 void Create(char* m,int& len) {

     char ch;

     int i=;

     cin>> ch;

     while( ch!='#') {

         m[i++] = ch;

         cin>> ch;

     }

     len = i;

 }

 void Show(char* m,int len) {

     for(int i=; i<len; ++i)

         cout<<m[i];

 }

 void Run(char* str,int length,int ton,int con,char* Arr,int& len) {

     int AL;

     if(ton==) {        //        R -> 10

         Ten_Other(str, length, con, Arr, AL);

     } else if(con==) { //        10 -> R

         Other_Ten(str, length, ton, Arr, AL);

     } else {

         Other_Ten(str, length, ton, Arr, AL);    // 先将原始进制转化为10 进制

         Ten_Other(Arr, AL, con, Arr, AL);        //再将10 进制 转化为目标进制

     }

     len = AL;

 }

 void Ten_Other(char* str,int length,int con,char* Array,int& AL) {

     Stack s;

     Queue q;                                //注： 本函数结束后自动析构 s q

     int i=, m=, len=length;

     double n=;

     while( str[i]!='.' && len!=) {        // 将整数存放在 m 中

         m = (((int)str[i]-'') + m)*;        ///

         i++;

         len--;

     }

     m = m / ;        // 注意：此时除以 10，因为上面的while中，对整数的末尾多乘了一次

     if(len!=) {    //判断是否有 .  有则将下标前置一个到小数点之后，

         i++;

         len--;

     }

     double tem=;    // 此处不能为int ，否则下面计算 n 所得的结果为整数：((int)(str[length-len]-48)) / tem，结果为整数

     while( len>) {        // 将小数部分存放在 n 中

         tem =  * tem;

         n = ((int)(str[length-len]-)) / tem + n;

         len--;

     }

     // 开始转换进制  m为整数部分， n为小数部分

     while( m!=) {    // 整数用栈

         tem = m % con;  // tem为全局变量

         m = m/con;

         s.Push(tem);    // tem可能大于9 ，即为十六进制数

     }    // 将取余所得的全部放入栈中

     i = ;    // i 为全局变量

     double dou=;

     while(i!= && n!=) {    // 对小数部分做五次运算  小数部分入队

         dou = n * con;

         m = dou;    //再次使用全局变量 tem ，当tem 中的内容不需要的时候可任意使用

         q.Add(m);

         n = dou - m;    // 去掉整数部分再次执行计算小数

     }    // 取得小数部分的进制数，可能含有十六进制所对应的字母序列

 //    char Array[20];     // 将数据存放在 数组里面

     char ch;

     i = ;        //  注: i++ 表示先用再加！

     if( s.Isempty()==true) {    // 判断是否含有整数，没有整数部分，应该放入 0，然后放 .  例如: 0 . 5124

         Array[i++] = '';

     }

     while( !s.Isempty()) {    // 栈不空，即栈含有数值，放入数组中

         m = s.GetTop();            // 得到的是数值

         if(m>= && m<=) {        // 通过上面的计算得到的数值都是在0 ~ 15 之间

             ch = m + ;        // 45的ASCII码为 字符 0

         } else {

             ch = m + ;        // 若 m = 10; 则因为 A ； 65 = 10 + 55；

         }

         Array[i++] = ch;

         s.Pop();                // 将已访问过得头结点出栈，即删除

     }        // 整数部分放完

     if( !q.Isempty()) {        // 队列 q 不空，表示含有小数位，故需要小数点 “ . ”， 若无小数位，则不需要“ . ”

         Array[i++] = '.';

     }

     while( !q.Isempty()) {

         m = q.GetTop();            // 得到的是数值

         if(m>= && m<=) {        // 通过上面的计算得到的数值都是在0 ~ 15 之间

             ch = m + ;        // 45的ASCII码为 字符 0

         } else {

             ch = m + ;        // 若 m = 10; 则因为 A ； 65 = 10 + 55；

         }

         Array[i++] = ch;

         q.Drop();

     }

     AL = i;        // 注意： 此时的 i 变成了数组的组长，所以将组长存放在 AL中

 }

 void Other_Ten(char* str,int length,int Other,char* Array,int& AL) {

     Stack s;

     Queue q;                                //注： 本函数结束后自动析构 s q

     int i=, len=length, Integer=, m=;

     double Dicimal=;    // len为length的一份拷贝 Integer存放整数 Dicimal 小数

     int tem=;

     while(str[i]!='.' && len!=) {            // 整数的数值入队,不含小数点

         tem = str[i]- ;

         if(str[i]>='A' && str[i]<='F') {         //当为十六进制的时候 就不能够 减去字符 0 的ascii码而得到目标数值

             tem = str[i]- ;

         }

         q.Add( tem);

         len--;

         i++;

     }    // i 为队长  len 为入队后剩余的字符个数

     while(i!=) {            // 不计算倒数第一位

         m = q.GetTop();        //获取头结点

         q.Drop();            //将头结点出栈删除

         Integer = (m + Integer) * Other;

         i--;

     }

     Integer = Integer + (int)q.GetTop();    // 计算最后一位，整个值加上最后一个值，得到整数部分的目标进制数

     q.Drop();

     // 以上整数部分操作完毕

     len--;    // len--后，为-1，表str全为整数，为0，表剩余一个 ‘ . ’， 大于0，表含有小数点，且点后有数

     while( len>) {

         m = str[length-len]- ;

         if( str[length-len]>='A' && str[length-len]<='F') {

             m = str[length-len] - ;

         }

         s.Push( m);    // length-len,例如，共长8，小数位为3， 8-3=5，此时的str[5]为小数位第一个

         len--;

     }        //将小数位全部入栈

     while( !s.Isempty()) {    // s不空表示含有小数位

         m = s.GetTop();

         s.Pop();        // m 为全局变量,再次使用

         Dicimal = (m + Dicimal) / Other;

     }    

 //    cout<<Integer+Dicimal<<"（D）"<<endl;        得到的数值，为了统一将其放入数组中

 //    以下全部为了将数据放入数组中，    一开始未意识到，故此多了一些代码段

     i = ;

     if(Integer==) {

         Array[i++] = '';

     }

     while(Integer!=) {    // 将整型入栈

         m = Integer % ; // m 为整型

         Integer = Integer / ;

         s.Push(m);

     }

     char ch;

     while(!s.Isempty()) {    // 将栈元素放入数组

         ch = s.GetTop() + ;

         s.Pop();

         if( ch>'') {        // 判断是否为十六进制数

             ch = ch + ;

         }

         Array[i++] = ch;

     }

     if(Dicimal!=) {

         Array[i++] = '.';

     } 

     while(Dicimal!=) {

         Dicimal = Dicimal * ;

         m = Dicimal;

         Dicimal = Dicimal - m;

         q.Add(m);

     }

     while(!q.Isempty()) {

         ch = q.GetTop() + ;

         q.Drop();

         if( ch>'') {        // 判断是否为十六进制数

             ch = ch + ;

         }

         Array[i++] = ch;

     }

     AL = i;

 }

 Stack::Stack() {

     Head = new Node();

     Head->Next = NULL;

 }

 Stack::~Stack() {

     Node * p;

     while(Head) {

         p = Head;

         Head = Head->Next;

         delete p;

     }

 }

 char Stack::GetTop() {

     if(Isempty()) {

         return '\0';

     } else {

         return Head->data;

     }

 }

 bool Stack::Push(char ch) {

     Node * pNew = new Node();

     pNew->data = ch;

     pNew->Next = Head;

     Head = pNew;

     return true;

 }

 bool Stack::Pop() {

     if(Isempty()) {

         return false;

     } else {

         Node * tem = Head;

         Head = Head->Next;

         delete tem;

     }

     return true;

 }

 bool Stack::Isempty() {

     return Head->Next==NULL;

 }

 Queue::Queue() {

     Head = new Node();

     Head->Next = NULL;

     Tail = Head;

 }

 Queue::~Queue() {

     Node * p;

     while(Head) {

         p = Head;

         Head = Head->Next;

         delete p;

     }

     Tail = NULL;

 }

 char Queue::GetTop() {

     if(Isempty()) {

         return '\0';

     } else {

         return Head->Next->data;

     }

 }

 bool Queue::Add(char ch) {

     Node * pNew = new Node();

     pNew->data = ch;

     Tail->Next = pNew;

     pNew->Next = NULL;

     Tail = pNew;

     return true;

 }

 bool Queue::Drop() {

     if(Isempty()) {

         return false;

     } else {

         Node * tem = Head;

         Head = tem->Next;

         delete tem;

     }

     return true;

 }

 bool Queue::Isempty() {

     return Head==Tail;

 }

巴特西

进制转换（ C++字符数组）

最新文章

热门文章

巴特西

进制转换（ C++字符数组 ）

最新文章

热门文章

进制转换（ C++字符数组）