对于输入的任意一个非负十进制整数，打印输出与其等值的十六进制数

【问题描述】对于输入的任意一个非负十进制整数，打印输出与其等值的十六进制数
【输入形式】非负十进制整数
【输出形式】输出相应十进制整数转换后的十六进制数，若输入不符合要求，提示错误，重新输入
【样例输入】31
【样例输出】1F
【样例说明】先判断输入是否符合非负正整数要求,若输入不符合要求，提示:"输入错误,请重新输入:".
【评分标准】

主函数

#include"_STACK_H_.h"


int main(void)
{
	int a;
	int b;
	int c;
	Stack_Order stack;
	while (true)
	{	
		int input=scanf("%d", &a);
		if (a < 0)
		{
			printf("输入错误,请重新输入:\n");
		}
		else
		{
			if (a==0)
			{
				printf("%d", a);
			}
			else
			{
				Order_Creat_Stack(&stack);
				while (a >= 1)
				{
					b = a % 16;
					Order_Stack_Push(&stack, &b);
					a = (a - b) / 16;
				}
				while (Order_Stack_Judgment(&stack) == false)
				{
					Order_Stack_Pop(&stack, &c);
					if (c == 10)
					{
						printf("A");
					}
					else if (c == 11)
					{
						printf("B");
					}
					else if (c == 12)
					{
						printf("C");
					}
					else if (c == 13)
					{
						printf("D");
					}
					else if (c == 14)
					{
						printf("E");
					}
					else if (c == 15)
					{
						printf("F");
					}
					else
					{
						printf("%d", c);
					}
				}
			}
			break;
		}
	}
}

头文件

#ifndef _STACK_H_
#define _STACK_H_

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>

/*特殊量定义区*/

//栈的数据类型
#define Data_Type int

//顺序栈的大小
#define Data_Size 10

/*结构体定义区*/

//数据域结构体
typedef struct Data
{
	Data_Type data[Data_Size];
	int stack_top;
}Stack_Order;

typedef Stack_Order* PStack;
/*函数声明区*/

//操作：	创建一个空栈
//前置条件：传入一个栈的指针
//后置条件：如果创建成功返回true,否则返回false
bool Order_Creat_Stack(PStack pstack);

//操作：	把一个栈置为空栈
//前置条件：传入一个栈的指针
//后置条件：如果创建成功返回true,否则返回false
bool Order_Stack_Empty(PStack pstack);

//操作：	判断栈是否为空栈
//前置条件：输入一个栈的地址
//后置条件：如果栈为空返回true,否则返回false
bool Order_Stack_Judgment(PStack pstack);

//操作：	返回栈的长度 
//前置条件：输入一个栈的地址
//后置条件：返回栈的长度
int Order_Stack_Long(PStack pstack);

//操作：	插入一个元素data为栈顶元素
//前置条件：输入一个栈的地址，和插入元素的地址
//后置条件：插入成功返回ture,否则返回false
bool Order_Stack_Push(PStack pstack,Data_Type* data);

//操作：	弹出栈顶元素
//前置条件：输入一个栈的地址，一个栈数据类型data的地址
//后置条件：将栈顶数据交给data，删除栈顶元素，成功返回true,否则返回false
bool Order_Stack_Pop(PStack pstack,Data_Type* data);

//操作：	输出栈顶元素
//前置条件：输入一个栈的地址，一个栈数据类型data的地址
//后置条件：成功返回true,否则返回false
bool Order_Stack_GetTop(PStack pstack, Data_Type* data);

//操作：	从栈底到栈顶依次对栈中每个元素显示 
//前置条件：输入栈的地址
void Order_Stack_Print(Stack_Order stack);

//操作：	打印当前数据
//前置条件：输入当前数据
void Order_Stack_visit(Data_Type data);


#endif // !_STACK_H_

引用函数

#include"_STACK_H_.h"

bool Order_Creat_Stack(PStack pstack)
{
	pstack->stack_top = -1;
	return true;
}

bool Order_Stack_Empty(PStack pstack)
{
		pstack->stack_top = -1;
		return true;
}

bool Order_Stack_Judgment(PStack pstack)
{
	if (pstack->stack_top == -1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

int Order_Stack_Long(PStack pstack)
{
	return pstack->stack_top + 1;
}

bool Order_Stack_Push(PStack pstack,Data_Type* data)
{
	if (pstack->stack_top == Data_Size - 1) 
	{
		return false;
	}
	else
	{
		pstack->stack_top++;
		pstack->data[pstack->stack_top]=*data;  
		return true;
	}
}

bool Order_Stack_Pop(PStack pstack, Data_Type* data)
{
	if (pstack->stack_top==-1)
	{
		return false;
	}
	else
	{
		*data = pstack->data[pstack->stack_top];
		pstack->stack_top--;
		return true;
	}
}

void Order_Stack_Print(Stack_Order stack)
{
	int i;
	i = 0;
	while (i <=stack.stack_top)
	{
		Order_Stack_visit(stack.data[i++]);
	}
	printf("\n");
}

void Order_Stack_visit(Data_Type data)
{
	printf("%d ",data);
}

bool Order_Stack_GetTop(PStack pstack, Data_Type* data)
{
	if (pstack->stack_top == -1)
	{
		return false;
	}
	else
	{
		*data = pstack->data[pstack->stack_top];
		return true;
	}
}