图片说明
//主要功能：实现带小数二进制和十进制之间数据的转换
#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();//清屏
    }
}//主函数结束
c++清空一个二进制文件

David0104

3个回复
