//主要功能：实现带小数二进制和十进制之间数据的转换
#include <iostream.h>
#include <windows.h>
#include <fstream.h>
#include <string>
#include <math.h>
using namespace std;
const int TAILMAXLENTH=10;//定义十进制转换成二进制小数部分最大位数
const int DABAMAXLENTH=40;//定义原始数据的最大长度
const double ADDMENBERNUM=111.11;//定义一个加数用于检测数据真实可用
/*********************************************************************************************************
*栈的部分
*********************************************************************************************************/
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()//销毁一个栈
{
//while(pop());//不停地出栈，而每次释放空间在出栈函数中完成
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;//栈顶指针后移
// delete usednodep;//释放空间
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)//清空链队
{
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;
// item=tempp->data;//保存数据
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(array[i]-48>=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(flag==0)//取整数数据
inter=inter*number+array[i]-48;
if(flag==1)//取小数数据
floater+=(float)(((int)array[i]-48)*(float)pow(number,--j));
}
}
double NumSysConversion::change_to_aim(int tokind)//将原始数据转化成目标进制的数据
{
int count=0,temp,flag=0,num;
double resnumb=0;
//第一步：先将整数部分转换进制后的数据依次入栈
while(inter)
{
num=inter%tokind;
stack->push(num);
inter/=tokind;
}
//第二步：再将小数部分转换进制后的数据依次入队
while(floater&&count<TAILMAXLENTH)
{
queue->append(int(floater*tokind));
floater*=tokind;
if(floater>=1)
floater-=(int)floater;
count++;
}
//第三步：显示栈和队中的数据并将其转换成可用数据
cout<<"数据转换后为：";
while(!stack->empty())
{
stack->top(temp);
stack->pop();
cout<<temp;
resnumb=resnumb*tokind+temp;
flag=1;
}
if(!queue->empty())
{
if(flag==0)
cout<<"0";
cout<<".";
count=-1;
}
while(!queue->empty())
{
queue->retrieve(temp);
queue->serve();
cout<<temp;
resnumb+=temp*pow(tokind,count--);
}
cout<<endl;
//第四步：清空栈和队中的数据
stack->clear();
queue->clear();
inter=0;
floater=0;
//第五步：将可用数据信息返回
return resnumb;
}
/*
定义一个实现进制转换功能的菜单处理类interfacebase
*/
class interfacebase
{
private:
NumSysConversion NumSysConversiononface;
public:
void clearscreen(void);//清屏
void showmenu(void);//显示菜单函数
int userchoice(void);//用户的选项
void processmenu(int menuchoice);//菜单函数
};
/*
类interfacebase的实现部分
*/
void interfacebase::clearscreen(void)
{
system("cls");
}
void interfacebase::showmenu(void)
{
cout<<"进制转换功能菜单"<<endl;
cout<<"================"<<endl;
cout<<"1.十进制转换为二进制"<<endl;
cout<<"2.二进制转换为十进制"<<endl;
cout<<"0.结束程序"<<endl;
cout<<"================"<<endl;
}
int interfacebase::userchoice(void)
{
int menuchoice;
cout<<"请输入您的选择：";
cin>>menuchoice;
return menuchoice;
}
void interfacebase::processmenu(int menuchoice)
{
switch(menuchoice)//根据用户的选择进行相应的操作
{
case 1:
{
char array[10]={'0','.','1','2','5'};
int number=10;
if(NumSysConversiononface.check(array,number))
cout<<"符合要求！"<<endl;
else
cout<<"不符合要求！"<<endl;
NumSysConversiononface.change(array,number);
cout<<NumSysConversiononface.change_to_aim(2)<<endl;
cout<<"进制转换成功！"<<endl;
}
break;
case 2:
{
char array[10]={'1','1','1','1'};
int number=2;
if(NumSysConversiononface.check(array,number))
cout<<"符合要求！"<<endl;
else
cout<<"不符合要求！"<<endl;
NumSysConversiononface.change(array,number);
cout<<NumSysConversiononface.change_to_aim(10)<<endl;
cout<<"进制转换成功！"<<endl;
}
break;
case 0:
exit(0);
default:
cout<<"对不起，您输入的功能编号有错！请重新输入！！！"<<endl;
break;
}
}
/*
程序主入口
*/
void main(void)
{
int menuchoice;//定义变量，菜单选单项的选择
interfacebase interfacenow;
system("color f0");//修改屏幕的背景色和字的颜色
interfacenow.clearscreen();//清屏
while(1)//永真循环
{
interfacenow.showmenu();//显示菜单
menuchoice=interfacenow.userchoice();//获取用户的选择
interfacenow.processmenu(menuchoice);//处理用户的选择
system("pause");//暂停
interfacenow.clearscreen();//清屏
}
}//主函数结束
