//主要功能:实现带小数X进制和Y进制之间数据的转换
#include <iostream>
#include <iomanip>
#include <windows.h>
#include <fstream>
#include <string>
#include <math.h>
using namespace std;
const int TAILMAXLENTH=10;//定义进制转换时小数部分的最大位数
const int DABAMAXLENTH=40;//定义原始数据的最大长度
const double ADDMENBERNUM=111.11;//定义一个加数用于检测数据真实可用
static int size=0;//小数位数
/*********************************************************************************************************
*栈的部分
*********************************************************************************************************/
class Stack;//类Stack的声明
/*
定义一个链栈结点类Stacknode
*/
class Stacknode
{
friend class Stack;//申请友元类
private:
Stacknode(Stacknode *nextp=NULL);//构造函数
Stacknode(int &newdata,Stacknode *nextp=NULL);//构造函数
int data;//数据元素
Stacknode *next;//递归定义指向后继结点的指针
};
/*
Stacknode的实现部分
*/
Stacknode::Stacknode(Stacknode *nextp)//构造函数
{
next=nextp;
}
Stacknode::Stacknode(int &newdata,Stacknode *nextp)//构造函数
{
data=newdata;
next=nextp;
}
//结点类Stacknode的定义结束
/*
定义一个链栈类Stack
*/
class Stack
{
public:
Stack();//创建一个空栈
~Stack();//回收一个栈
void clear();//销毁一个栈
bool empty() const;//确定栈是否已空
bool push(int &item);//把数据压进栈
bool pop();//出栈
bool top(int &item) const;//取出栈顶元素
private:
Stacknode *newnode(Stacknode *nextp=NULL);
Stacknode *newnode(int &item,Stacknode *nextp=NULL);//创建新的结点
Stacknode *Stacktop;
int Stacklength;
};
/*
Stack的实现部分
*/
Stacknode *Stack::newnode(Stacknode *nextp)//创建新的结点,不带数据
{
return new Stacknode(nextp);
}
Stacknode *Stack::newnode(int &item,Stacknode *nextp)//创建新的结点,数据域赋值
{
return new Stacknode(item,nextp);
}
//以下为栈类Stack的函数定义
Stack::Stack()//创建一个空栈
{
Stacktop=newnode();//创建一个栈顶指针初始化,相当于Stacktop=NULL;本链表没有用头结点
Stacklength=0;
}
Stack::~Stack()//回收一个栈
{
clear();
delete Stacktop;//释放栈底
}
void Stack::clear()//销毁一个栈
{
Stacknode *usednodep;//定义指针usednodep,准备指向出栈的结点
while(Stacktop->next!=NULL)
{
usednodep=Stacktop;//指向出栈的结点
Stacktop=Stacktop->next;//栈顶指针后移
delete usednodep;//释放空间
}
}
bool Stack::empty() const//确定栈是否已空
{
return Stacklength<=0?true:false;
}
bool Stack::push(int &item)//数据进栈
{
Stacknode *newnodep;//定义指针newnodep,准备指向申请的新结点
newnodep=newnode(item,Stacktop);//申请新结点,把数据存入,把指针域指向头指针
if(!newnodep)//如果没有申请到空间,返回失败
return false;
Stacktop=newnodep;//改链,完成进栈
Stacklength++;//栈的长度增加
return true;//本次操作成功
}
bool Stack::pop()//出栈,不要栈顶数据
{
Stacknode *usednodep;//定义指针usednodep,准备指向出栈的结点
if(!empty())//判断是否栈空
{
usednodep=Stacktop;//指向出栈的结点
Stacktop=Stacktop->next;//栈顶指针后移
Stacklength--;//栈的长度减少
return true;//本次操作成功
}
return false;//否则本次操作失败
}
bool Stack::top(int &item) const//取出栈顶数据返回去
{
if(!empty())//如果栈不空,记录当前栈顶元素
{
item=Stacktop->data;//通过item返回去
return true;//本次操作成功
}
return false;//否则本次操作失败
}
/*********************************************************************************************************
*队列的部分
*********************************************************************************************************/
/*
定义一个结点类node
*/
class node
{
public:
int data;
node *next;
};
/*
定义一个链队类Queue
*/
class Queue
{
private:
node *rear;
node *front;
protected:
int count;//计数器,统计结点个数即线性队列的长度
public:
Queue();//构造函数
~Queue();//析构函数
void clear(void);//清空链队
bool empty(void) const;//判断是否空队
bool retrieve(int &item) const;//读取队头
bool append(const int &item);//数据入队
bool serve();//数据出队
};
/*
类Queue的实现部分
*/
Queue::Queue()//构造函数
{
front=new node;//申请新结点,作为队头结点
front->next=NULL;
rear=front;//队尾指针指向队头
count=0;//计数器清零,队列开始时没有实际数据
}
Queue::~Queue()//析构函数
{
clear();//删除所有数据,释放所有结点
delete front;//把头结点也释放掉
count=0;//计数器清零,队列开始时没有实际数据
}
void Queue::clear(void)//清空链队
{
if(count==0)
return;
node *searchp=front->next,*followp=front;//初始化两个指针
while(searchp!=rear)
{
followp=searchp;
searchp=searchp->next;
delete followp;
}
front->next=NULL;//保留了最后一个结点,就是头结点,并且链域置为空
rear=front;
count=0;//计数器也清零
}
bool Queue::empty(void) const//判断是否空链
{
return count==0?true:false;
}
bool Queue::retrieve(int &item) const//读取队头
{
if(empty())//处理意外
return false;
item=front->next->data;//返回读取的数据
return true;//本次操作成功
}
bool Queue::append(const int &item)//进队
{
node *newnodep=new node;
newnodep->data=item;//给数据赋值
rear->next=newnodep;//这一步可以看出有头结点
rear=rear->next;//改动队尾指针的位置
count++;//计数器加1
return true;
}
bool Queue::serve()//出队
{
if(empty())//空队处理
return false;
node *tempp=front->next;
front->next=tempp->next;//改变指针
delete tempp;//释放该结点
count--;//计数器减1
return true;
}
/*********************************************************************************************************
*定义一个功能类NumSysConversion
*********************************************************************************************************/
class NumSysConversion
{
private:
int inter;
float floater;
Stack *stack;
Queue *queue;
public:
NumSysConversion();//构造函数
~NumSysConversion();//析构函数
bool check(char *array,int number);//检查输入数据是否符合要求
void change(char *array,int number);//将原始数据转化成数值(十进制数)
double change_to_aim(int tokind);//将原始数据转化成目标进制的数据
};
NumSysConversion::NumSysConversion()//构造函数
{
stack=new Stack;
queue=new Queue;
inter=0;
floater=0;
}
NumSysConversion::~NumSysConversion()//析构函数
{
delete stack;
delete queue;
}
bool NumSysConversion::check(char *array,int number)//检查输入数据是否符合要求
{
bool flag=true;
for(int i=0;array[i]!='\0';i++)
{
cout<<array[i];
if(('0'<=array[i]&&array[i]<='9')&&(array[i]-48>=number) || ('A'<=array[i]&&array[i]<='Z')&&(array[i]-55>=number))
{
flag=false;
break;
}
}
return flag;
}
void NumSysConversion::change(char *array,int number)//将原始数据转化成数值(十进制数)
{
int flag=0,j=0;
for(int i=0;array[i]!='\0';i++)
{
if(array[i]=='.')
{
flag=1;
continue;
}
if('0'<=array[i]&&array[i]<='9')
{
if(flag==0)//取整数数据
inter=inter*number+array[i]-48;
if(flag==1)//取小数数据
floater+=(float)(((int)array[i]-48)*(float)pow(number,--j));
}
if('A'<=array[i]&&array[i]<='Z')
{
if(flag==0)//取整数数据
inter=inter*number+array[i]-55;
if(flag==1)//取小数数据
floater+=(float)(((int)array[i]-55)*(float)pow(number,--j));
}
}
}
double NumSysConversion::change_to_aim(int tokind)//将原始数据转化成目标进制的数据
{
int count=0,temp,flag=0,remainder,hexadecimalinter=0,hexadecimalfloater=0;
char hexadecimal;
double resnumb=0;
//第一步:先将整数部分转换进制后的数据依次入栈
while(inter)
{
remainder=inter%tokind;
stack->push(remainder);
inter/=tokind;
if(hexadecimalinter==0)
{
if(remainder<10)
{
resnumb +=remainder*pow(10,hexadecimalinter);
hexadecimalinter=1;
}
else
{
resnumb +=remainder*pow(10,hexadecimalinter);
hexadecimalinter=2;
}
}
else
{
if(remainder<10)
{
resnumb +=remainder*pow(10,hexadecimalinter);
hexadecimalinter+=1;
}
else
{
resnumb +=remainder*po