c语言停车场管理系统
A. c# 编程停车场系统
建一个 车 的类 做为 父类。。 其他车辆的种类继承 车这个父类，重写父类的计算价格的方法。。然后停车场做为一个类。 他有一个方法，就是停车， 和 一个存储所有停车位信息的集合。停车的方法有一个参数。一个参数为 车的信息（类型为父类类型）。。这样的话就可以计算出你需要的所有所有信息
C语言数据结构 车队管理
我的结题思路：
车的状态分三种，用switch语句分开{
1：停车 A
库未满，往车库里停车
库满，往便道里停车
2：出车 D
从车库里出车使用临时车库
从变道里出车，使用临时便道
3：停止输入 E
}
注意：
1：请勿略下面代码中 “还没有计算位置” 写的时候提醒自己，上传时我忘删了
2：使用静态数组来记录进去的时间 ，用 a[车牌号]
3：用静态 i 来记录进车库里的进出车
进车 i++
出车 i--
4:在写最关键部分时，我是用到了才定义，所以看着有乱，包含哈-_- -_-
二、关键代码//我用的是VS2013
#include<stdlib.h>
#include<stdio.h>
#include<iostream>
usingnamespacestd;
staticinti=1;
staticinta[100];
#defineSTACK_INITSIZE100
#defineStackIncrement10
#defineOK1
#defineERROR0//结构体..............................................................................
typedefstructGARAGE{//创建车库的结构体
int*base;
int*top;
intstacksize;
intOutTime;
}Garage;
typedefstructTPGarage{//创建临时车库的结构体
int*base;
int*top;
intstacksize;
}TpGarage;
typedefstructQNode{
intdate;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{//创建便道的结构体
QueuePtrfront;
QueuePtrrear;
}OtGarage;
typedefstructTNode{//创建临时便道的结构体
intTdate;
structTNode*Tnext;
}TNode,*TQueuePtr;
typedefstruct{
TQueuePtrTfront;
TQueuePtrTrear;
}TOtGarage;
//.....................................................机构体..................
//...........................................声明........................
voidInitGarage(Garage&S,intt);//车库
voidPushGarage(Garage&S,intchp,intt);
voidZPushGarage(Garage&S,intchp);
voidGetTopGarage(TOtGarage&TG,OtGarage&OG,TpGarage&T,Garage&S,intchp,intt);
intPop(Garage&S,int&GH);
voidInitTpStack(TpGarage&T);//临时车库
voidPushTpStack(TpGarage&T,intchp);
voidPopTpStack(TpGarage&T,int&chp);
voidInitOtGarage(OtGarage&OG);//变道
voidPushTpStack(TpGarage&T,intchp);
intOutOtGarage(OtGarage&OG,int&e);
voidInitTOtGarage(TOtGarage&TG);//临时便道
voidTEnOtGarage(TOtGarage&TG,int&Te);
intTOutOtGarage(TOtGarage&TG,int&Te);
inttranverse(GarageS,intt);//遍历车库
intPush(charX,intchp,intt,Garage&S,TpGarage&T,OtGarage&OG,TOtGarage&TG);//枢纽
//............................................声明.......................................
//.................................车库........................................................
voidInitGarage(Garage&S,intt){//初始化出库
S.stacksize=t;
S.base=(int*)malloc(S.stacksize*sizeof(int));
S.top=S.base;
}
voidPushGarage(Garage&S,intchp,intt){//车库进车
a[chp]=t;//记录当前的时间
*(S.top)++=chp;
}
voidZPushGarage(Garage&S,intchp){//车库进车
*(S.top)=chp;
S.top++;
}
voidGetTopGarage(TOtGarage&TG,OtGarage&OG,TpGarage&T,Garage&S,intchp,intt){//车库中出
intkeepch=chp;//将当前的车牌保存下来
intgh=0;
intnum;
intfh=0;
inti=0;//记住车库出去车的量
inte=0;//做一个遍历，找出该车的位置
intjs=0;
intTe=0;
S.OutTime=t;//是的话，直接出车，删掉元素
if(tranverse(S,chp)){//做一个遍历，该车在车库的话，就从车库中出车
while(Pop(S,gh)!=keepch){//让车库的车出去
PushTpStack(T,gh);
i++;
}
if(num=(S.OutTime-a[chp])%10==0){
num=S.OutTime-a[chp];
}
elsenum=((S.OutTime-a[chp])/10+1)*10;
cout<<"该车在停车场的时间为"<<num<<//此时输出该车的信息
"分钟，应该收费为"<<0.5*num<<"元"<<endl;
for(size_tj=0;j<i;j++){
PopTpStack(T,fh);//依次将其他开回来，往前挪一位，空出门前的车位
ZPushGarage(S,fh);
}
if(OutOtGarage(OG,e)){//当变道里有车时，从外面再进来一辆车
PushGarage(S,e,S.OutTime);
}
}
else{//注意第一个if,这里是对应的else，表示车要从临时便道里出车
//将便道里的车送到临时便道，
inty=OutOtGarage(OG,gh);
while(gh!=keepch){//让车库的车出去OutOtGarage(OtGarage&OG,int&e)
TEnOtGarage(TG,gh);//推到临时车道
js++;
y=OutOtGarage(OG,gh);
}
if(js==0){//后面的车往前开
//直接从停车场出去
cout<<"该车未在车库停车，无需缴费"<<endl;
}
elseif(!OutOtGarage(OG,e)){//如果此时为底的话，再重新进入变道
for(size_tj=0;j<i;j++){
intv;
v=TOutOtGarage(TG,Te);//
PushTpStack(T,Te);//还没有计算位置
}i--;
cout<<"该车未在车库停车，无需缴费"<<endl;
}
else{
cout<<"该车未在车库停车，无需缴费"<<endl;
intjd;
QueuePtrp;//变道有车的话，返回一个
p=OG.front->next;
e=p->date;
OG.front->next=p->next;
if(OG.rear==p)
OG.rear=OG.front;
free(p);
//先释放一个节点，继续传
while(OutOtGarage(OG,gh)){//让车库的车出去OutOtGarage(OtGarage&OG,int&e)
TEnOtGarage(TG,gh);//推到临时车道
}
while(TOutOtGarage(TG,Te)){
PushTpStack(T,Te);
}i--;
}//如果此时不为底的话，继续进入临时便道，再进入变道
}
}
intPop(Garage&S,int&GH){//车库中出车
GH=*--S.top;
returnGH;
}
//....................................车库.........................
//...............................临时车库..........................
voidInitTpStack(TpGarage&T){//初始化临时车库
T.stacksize=STACK_INITSIZE;
T.base=(int*)malloc(T.stacksize*sizeof(int));
T.top=T.base;
}
voidPushTpStack(TpGarage&T,intchp){
if(T.top-T.base>=T.stacksize){
T.base=(int*)realloc(T.base,
(T.stacksize+STACK_INITSIZE)*sizeof(int));
T.top=T.base+T.stacksize;
T.stacksize+=STACK_INITSIZE;
}
*T.top++=chp;
}
voidPopTpStack(TpGarage&T,int&chp){//当其为返回值为1的时候，删除栈顶且返回
chp=*--T.top;
}
//...........................临时车库.................................
//...........................变道....................................
voidInitOtGarage(OtGarage&OG){//初始化便道
OG.front=OG.rear=(QueuePtr)malloc(sizeof(QNode));
OG.front->next=NULL;
}
voidEnOtGarage(OtGarage&OG,int&e){//进入变道
QueuePtrp;
p=(QueuePtr)malloc(sizeof(QNode));//用来放置车牌号
p->date=e;
p->next=NULL;
OG.rear->next=p;
OG.rear=p;
cout<<"车库已满，该车在变道上的第"<<i<<"位"<<endl;
i++;
cout<<endl;
}
intOutOtGarage(OtGarage&OG,int&e){//变道出车
cout<<endl;//没有车的话，返回0
if(OG.front==OG.rear){
returnERROR;
}
QueuePtrp;//变道有车的话，返回一个
p=OG.front->next;
e=p->date;
OG.front->next=p->next;
if(OG.rear==p)
OG.rear=OG.front;
free(p);
i--;
returnOK;
}
voidInitTOtGarage(TOtGarage&TG){//初始化便道
TG.Tfront=TG.Trear=(TQueuePtr)malloc(sizeof(TNode));
TG.Tfront->Tnext=NULL;
}
voidTEnOtGarage(TOtGarage&TG,int&Te){//进入临时变道
TQueuePtrp;
p=(TQueuePtr)malloc(sizeof(TNode));//用来放置车牌号
p->Tdate=Te;
p->Tnext=NULL;
TG.Trear->Tnext=p;
TG.Trear=p;
//cout<<"车库已满，该车在变道上的第"<<i<<"位"<<endl;
i++;
cout<<endl;
}
intTOutOtGarage(TOtGarage&TG,int&Te){//临时变道出车
cout<<endl;//没有车的话，返回0
if(TG.Tfront==TG.Trear)
returnERROR;
TQueuePtrp;//临时变道有车的话，返回一个
p=TG.Tfront->Tnext;
Te=p->Tdate;
TG.Tfront->Tnext=p->Tnext;
if(TG.Trear==p)
TG.Trear=TG.Tfront;
free(p);
i--;
returnOK;
}
//........................................临时便道...........................
//............................总枢纽...........................................
intPush(charX,intchp,intt,Garage&S,TpGarage&T,OtGarage&OG,TOtGarage&TG){
switch(X){//判断该车是进入还是要离开
case'A':{//情况A，进入车库
if(S.top-S.base>=S.stacksize){
cout<<"时间在第"<<t<<"分钟,"<<"车牌号为"<<chp<<"的小车进入便道等待车位"<<endl;
//车库满，接下来该车进入便道
EnOtGarage(OG,chp);//调用进入变道的函数
}
else{
//cout<<"OOOOO"<<endl;
PushGarage(S,chp,t);//进入车库
}
returnOK;
}break;
case'D':{//情况D，离开车库
GetTopGarage(TG,OG,T,S,chp,t);//1:在车库中的出去
returnOK;
}break;
case'E':{//情况E，所有的车辆弄干净
returnERROR;
}break;
}
}
inttranverse(GarageS,intt){
while(S.top!=S.base){
S.top--;
if(t==*S.top)
returnOK;
}
returnERROR;
}
intmain(){
intnum;
charX;
inttime;
intchp;
intx;
GarageS;
TpGarageT;
OtGarageOG;
TOtGarageTG;
cout<<"温馨提示：本停车场每10分钟收费0.5元，不足10分钟的部分按10分钟收费。"<<endl;
cout<<"请输入停车车位的总数:";
cin>>num;
cout<<endl;
InitGarage(S,num);
InitTpStack(T);
InitOtGarage(OG);
InitTOtGarage(TG);
cout<<"输入停止的标志为(E00)"<<endl;
cout<<"停车信息(格式：（动作，车牌号，时间））："<<endl;do{
cout<<"请输入停车信息"<<endl;
cin>>X>>chp>>time;
x=Push(X,chp,time,S,T,OG,TG);
}while(x);
}
C. C语言停车场管理系统
/*----------------------------------------------------------------
// Copyright (C) 2009 沈阳工程学院信息安全工作室
// 版权所有。
//
// 文件名：模拟停车场问题.cpp
// 文件功能描述：模拟停车场问题
//
//
// 创建标识：20091214
//
// 修改标识：20091218
// 修改描述：完成编码
//----------------------------------------------------------------*/
//头文件
#include <iostream>
#include <malloc.h>
#include <string>
#include <windows.h>
//常量定义
#define MAX_STOP 4 //定义停车场最大停车数
#define MAX_PLATE 10 //定义车牌号最大长度
#define TIME_COUNT "秒" //定义时间单位
#define TIME_MS_TO_CONUT 1000 //定义时间进制，意为由TIME_COUNT到毫秒的进制
#define UNIT_PRICE 10 //定义单位时间收费标准
using namespace std; //使用std命名空间
//数据结构定义
//定义存储汽车信息的结构体
typedef struct
{
char license_plate[MAX_PLATE]; //汽车牌照号码，定义为一个字符指针类型
char state; //汽车当前状态，字符p表示停放在停车位上，字符s表示停放在便道上，每辆车的初始状态用字符i来进行表示
int time; //汽车停入停车场时的时间，用来计时收费
}CAR;
//定义模拟停车场的栈结构
typedef struct
{
CAR STOP[MAX_STOP]; //汽车信息的存储空间
int top; //用来指示栈顶位置的静态指针
}SeqStack;
//定义模拟便道的队列结构
typedef struct node
{
CAR WAIT; //汽车信息的存储空间
struct node *next; //用来指示队列位置的动态指针
}QNode; //链队列节点的类型
//定义链队列的收尾指针
typedef struct
{
QNode *front,*rear;
}LQueue; //将头尾指针封装在一起的链队
//函数声明
int Empty_LQueue(LQueue *q); //判队空
int LeaveCheck(SeqStack parking , char *license_plate); //检查离开的车是否在停车场中
int QueueLength(LQueue *q); //判队长度
int Out_LQueue(LQueue *&sidewalk , char *license_plate); //出队操作
int StackEmpty(SeqStack parking); //判断栈是否为空
int StackFull(SeqStack parking); //判断栈是否为满
int StackPop(SeqStack &parking); //出栈操作
int StackTop(SeqStack parking , char *license_plate , int &time);//取栈顶元素
void Car_come(SeqStack &parking , LQueue *&sidewalk); //有车到来时的操作
void Car_leave(SeqStack &parking , LQueue *&sidewalk); //有车离开的操作
void Display(SeqStack parking); //显示停车场内的所有信息 调试时用
void InitStack(SeqStack &parking); //初始化栈
void InitList(LQueue *&sidewalk); //初始化队列
void In_LQueue(LQueue *&sidewalk , char *license_plate); //进队操作
void Input_Check(char *license_plate); ////检验输入的车牌是否合法
void StackPush(SeqStack &parking , char *license_plate , int stop_time);//进栈操作
void main()
{
//定义变量
SeqStack parking;
LQueue *sidewalk = NULL;
char *choice = new char;
int flag = 1; //定义一个变量 判断是否退出
//初始化一个为空的停车场
InitStack(parking);
//初始化一个为空的便道
InitList(sidewalk);
//运行界面及功能选择
while(flag)
{
cout<<"\n\t 停车场模拟管理系统 \n\n";
cout<<"\t|--------------------------------------------------|\n\n";
cout<<"\t|本程序为停车场的模拟管理系统，有车到来时请按C键。|\n\n";
cout<<"\t|然后根据屏幕提示进行相关操作，有车要走时请按l键。|\n\n";
cout<<"\t|然后根据屏幕提示进行相关操作，查看停车场请按D键。|\n\n";
cout<<"\t|然后根据屏幕提示进行相关操作，要退出系统请按Q键。|\n\n";
cout<<"\t|--------------------------------------------------|\n\n";
cout<<"请选择操作：";
gets(choice);
if(1 != strlen(choice))
{
cout<<"请正确输入选项!";
continue;
}
else
{
switch(*choice)
{
case 'c':
case 'C':
{
Car_come(parking,sidewalk);break;
}
case 'l':
case 'L':
{
Car_leave(parking,sidewalk);break;
}
case 'q':
case 'Q':
{
flag=0;break;
}
case 'd':
case 'D':
{
Display(parking);break;
}
default:
cout<<"选择不正确！请重新选择！\n";
}
}
}
}
//有车到来时的操作
void Car_come(SeqStack &parking , LQueue *&sidewalk)
{
//定义变量
char license_plate[MAX_PLATE];
cout<<"请输入车辆的车牌号码：";
Input_Check(license_plate);
//判断停车场是否已满，满则进入便道，不满进入停车场
if(StackFull(parking))
{
In_LQueue(sidewalk , license_plate); //进入便道
cout<<"停车场已满请在便道等候,您的位置为"<<QueueLength(sidewalk)
<<endl;
}
else
{
StackPush(parking , license_plate , GetTickCount()); //进入停车场
cout<<"请进入停车场中的"<<parking.top+1<<"号停车位\n";
}
// Display(parking);
}
//有车离开时的操作
void Car_leave(SeqStack &parking , LQueue *&sidewalk)
{
//定义变量
SeqStack tmpparking; //定义临时停车场
char leave_license_plate[MAX_PLATE]; //要离开的车牌号
char license_plate[MAX_PLATE]; //存放从停车场中读出来的车牌信息
int time;
InitStack(tmpparking); //初始化临时停车场
//判断停车场中是否有车
if(StackEmpty(parking))
{
cout<<"当前停车场中没有车\n";
return; //退出子函数
}
cout<<"请输入要离开的车牌照：";
Input_Check(leave_license_plate);
cout<<"当前停车场中有"<<parking.top+1<<"辆车\n";
if(LeaveCheck(parking , leave_license_plate)) //判断车是否在停车场中
{
//车在停车场中
cout<<"您的车在"<<LeaveCheck(parking , leave_license_plate)<<"号车位上\n";
while(StackTop(parking , license_plate , time)
&& (strcmp(parking.STOP[parking.top].license_plate , leave_license_plate) != 0))
{
strcpy(parking.STOP[parking.top].license_plate , license_plate);
cout<<"牌照为"<<license_plate<<"的车暂时退出停车场"<<parking.top+1<<"号位\n";
StackPush(tmpparking , license_plate , time); //停车场中的车暂时退出 进入临时停车场
StackPop(parking); //出栈
}
cout<<"牌照为"<<license_plate<<"的车离开停车场"<<parking.top+1<<"号位\n";
cout<<"您在停车场中停了"<<(GetTickCount()-time)/TIME_MS_TO_CONUT<<TIME_COUNT<<endl; //输出所停时间信息
cout<<"应缴费用为"<<(GetTickCount()-time)/TIME_MS_TO_CONUT*UNIT_PRICE<<"元\n";; //输出费用信息
StackPop(parking); //出栈
//将临时停车场中的车停回停车场
while(StackEmpty(tmpparking) != 1)
{
StackTop(tmpparking , license_plate , time);
StackPush(parking , license_plate , time);
cout<<"牌照为"<<license_plate<<"的车进入停车场"<<parking.top+1<<"号位\n";
license_plate[0] = '\0';
StackPop(tmpparking);
}
if(parking.top+1 == MAX_STOP-1) //判断车离开前停车场是否停满
if(QueueLength(sidewalk)) //如果停满则判断便道上是否有车
{
//便道中有车 则从便道中停入停车场
Out_LQueue(sidewalk , license_plate); //出队
StackPush(parking , license_plate , GetTickCount()); //入栈
cout<<"在便道中牌照为"<<license_plate<<"的车进入停车场"<<parking.top+1<<"号位\n";
}
}
else
//车不在停车场中
cout<<"您的车不在停车场中！\n";
}
//初始化顺序栈
void InitStack(SeqStack &parking)
{
parking.top = -1;
}
//判栈空
int StackEmpty(SeqStack parking)
{
if(parking.top == -1)
return 1;
else
return 0;
}
//判栈满
int StackFull(SeqStack parking)
{
if(parking.top == MAX_STOP-1)
return 1;
else
return 0;
}
//入栈
void StackPush(SeqStack &parking , char *license_plate , int stop_time)
{
parking.top++;
strcpy(parking.STOP[parking.top].license_plate , license_plate);
parking.STOP[parking.top].state = 'p';
parking.STOP[parking.top].time = stop_time;
}
//出栈 返回栈顶指针
int StackPop(SeqStack &parking)
{
if(StackEmpty(parking))
return 0;
else
return parking.top--;
}
//取栈顶元素
int StackTop(SeqStack parking , char *license_plate , int &time)
{
if(StackEmpty(parking))
return 0;
else
{
strcpy(license_plate , parking.STOP[parking.top].license_plate);
time = parking.STOP[parking.top].time;
return 1;
}
}
//显示所有
void Display(SeqStack parking)
{
if(parking.top == -1)
printf("停车场为空\n");
else
{
while(parking.top != -1)
{
cout<<"车牌号为："<<parking.STOP[parking.top].license_plate;
cout<<"，停在"<<parking.top + 1 <<"号车位上";
cout<<"，已停"<<(GetTickCount()-parking.STOP[parking.top].time)/TIME_MS_TO_CONUT<<TIME_COUNT<<endl;
parking.top--;
}
}
}
//初始化队列
void InitList(LQueue *&sidewalk)
{
sidewalk = (LQueue *)malloc(sizeof(LQueue));
sidewalk->front=sidewalk->rear = NULL;
}
//入队
void In_LQueue(LQueue *&sidewalk,char *license_plate)
{
QNode *car_on_sidewalk;
car_on_sidewalk = (QNode *)malloc(sizeof(QNode)); //为新节点开辟新空间
strcpy(car_on_sidewalk->WAIT.license_plate , license_plate); //将数据写入节点
car_on_sidewalk->WAIT.state = 's'; //写入停车信息
car_on_sidewalk->WAIT.time = GetTickCount(); //写入停车时间
car_on_sidewalk->next = NULL;
if(Empty_LQueue(sidewalk)) //队空则创建第一个节点
sidewalk->front = sidewalk->rear = car_on_sidewalk;
else
{
//队非空插入队尾
sidewalk->rear->next = car_on_sidewalk;
sidewalk->rear = car_on_sidewalk;
}
}
//判队空
int Empty_LQueue(LQueue *q)
{
if(q->front == NULL)
return 1;
else
return 0;
}
//判队长度 返回队长
int QueueLength(LQueue *q)
{
QNode *p=q->front;
int i=0;
while(p != NULL)
{
i++;
p=p->next;
}
return i;
}
//出队 成功返回1 队空返回0
int Out_LQueue(LQueue *&sidewalk,char *license_plate)
{
QNode *car_on_sidewalk;
if(Empty_LQueue(sidewalk)) //如果队空返回0
return 0;
car_on_sidewalk = sidewalk->front;
strcpy(license_plate , car_on_sidewalk->WAIT.license_plate);//取出队头元素
if(sidewalk->front == sidewalk->rear) //队中只有一个元素
sidewalk->front = sidewalk->rear=NULL; //删除元素
else
sidewalk->front = sidewalk->front->next; //队头指针后移
free(car_on_sidewalk); //释放指针
return 1;
}
//检查离开的车是否在停车场中 返回车在停车场中位置 不在则返回0
int LeaveCheck(SeqStack parking,char *license_plate)
{
int flag = parking.top+1; //定义变量记录当前车在停车场中位置
if(StackEmpty(parking))
return 0;
else
{
//查找离开车所在位置
while(parking.top != -1 && strcmp(parking.STOP[parking.top].license_plate , license_plate) != 0)
{
flag--;
parking.top--;
}
return flag;
}
}
//检验输入的车牌是否合法
void Input_Check(char *license_plate)
{
int flag = 1;
int i;
string tmpstr;
while(flag)
{
cin>>tmpstr;
getchar();
if(tmpstr.length()<MAX_PLATE)
{
for(i=0;i<10;i++)
license_plate[i] = tmpstr.c_str()[i];
flag = 0;
}
else
cout<<"输入有误，请重新输入：";
}
}
以前的课设 你看看吧 纯手工的~~
D. 用C语言编写“停车场管理系统”
程序太大 不让发 我是分几次发过去的 打三个出现乱码了 我在重新发一次
/*初始化停车场信息，初始状态为第一层已经停有4辆车,
* 其车位号依次为1—4 , 停车时间依次为20, 15, 10 , 5
*/
void Init(struct Garage gar[][6])
{
int i, j;
/*给所有的车位的层号，车位号初始化，停车时间初始化为0，停车位全都初始化为空*/
for (i=0; i<2; i++)
{
for (j=0; j<6; j++)
{
gar[i][j].lay = i+1;
gar[i][j].garagenum = j+1;
gar[i][j].time = 0;
gar[i][j].isempty = 1;
}
}
/*第一层的1-4号车位停车*/
for (i=0; i<4; i++)
{
gar[0][i].isempty = 0;
}
strcpy(gar[0][0].carnum, "GF8888"); /*我自己初始化的车牌号，你可以自己改一下*/
gar[0][0].time = 20;
strcpy(gar[0][1].carnum, "GF6666");
gar[0][1].time = 15;
strcpy(gar[0][2].carnum, "GF9999");
gar[0][2].time = 10;
strcpy(gar[0][3].carnum, "GF5858");
gar[0][3].time = 5;
}
/*新停入的汽车后，将在此之前的所有车的停车时间加5*/
void AddTime(struct Garage gar[][6])
{
int i, j;
for (i=0; i<2; i++)
{
for (j=0; j<6; j++)
{
if (gar[i][j].isempty == 0)
{
gar[i][j].time += 5;
}
}
}
}
/*停车*/
void Park(struct Garage gar[][6])
{
int i;
char num[8];
printf("请输入车牌号：");
scanf("%s", num);
/*查找空车位*/
for (i=0; i<6; i++)
{
if (gar[0][i].isempty == 1)
{
printf("第一层第%d号车位空着，请在此处停车\n", i+1);
strcpy(gar[0][i].carnum, num);
printf("车牌号：%s 层号：1 车位号： %d \n", num, i+1);
AddTime(gar); /*在此之前停车的所有汽车时间加5*/
gar[0][i].isempty = 0; /*表示该车为已经停车*/
gar[0][i].time = 5; /*将时间设为5*/
return;
}
}
printf("第一层已经没有空车位\n");
for (i=0; i<6; i++)
{
if (gar[1][i].isempty = 1)
{
printf("第二层第%d号车位空着，请在此处停车\n", i+1);
strcpy(gar[1][i].carnum, num);
printf("车牌号：%s 层号：2 车位号： %d \n", num, i+1);
AddTime(gar); /*在此之前停车的所有汽车时间加5*/
gar[1][i].isempty = 0; /*表示该车为已经停车*/
gar[1][i].time = 5; /*将时间设为5*/
return;
}
}
printf("对不起，1 2层都没有空车位，您现在不能在此停车\n");
}
/*查看所有车辆信息*/
void Information(struct Garage gar[][6])
{
int i, j;
printf(" 车牌号 层号 车位号 停车时间\n");
for (i=0; i<2; i++)
{
for(j=0; j<6; j++)
{
if (gar[i][j].isempty == 0)
printf(" %s%8d%8d%8d\n", gar[i][j].carnum, gar[i][j].lay, gar[i][j].garagenum, gar[i][j].time);
}
}
printf("\n");
}
/*取车*/
double Leave(struct Garage gar[2][6])
{
int i, j;
char num[8];
double charge = 0;
printf("请输入要取的车牌号：");
scanf("%s", num);
for (i=0; i<2; i++)
{
for (j=0; j<6; j++)
{
if (!strcmp(gar[i][j].carnum, num))
{
printf("您在%d层%d车位停车%d分钟\n", gar[i][j].lay, gar[i][j].garagenum, gar[i][j].time);
charge = gar[i][j].time/5*0.2;
printf("停车费用为每5分钟0.2元，您需交%.2lf元\n", charge);
gar[i][j].isempty = 1;
return charge;
}
}
}
printf("没有您输入的车号。\n\n");
return charge;
}
/*是否查看总收入*/
void IsPrintTotal(double total)
{
char ch;
printf("是否查看停车收费总计？Y/N");
scanf("%c", &ch);
while (ch!='y' && ch!='Y' && ch!='n' && ch!='N')
{
printf("请输入Y或N ");
scanf("%c", &ch);
printf("\n");
}
switch (ch)
{
case 'Y':
case 'y':
printf("停车收费总计为%.2lf元\n", total);
break;
case 'N':
case 'n':
break;
}
}
main()
{
int choice;
double total = 0;
struct Garage gar[2][6];
Init(gar); //初始化第一层已经停有的4辆车
while (1)
{
Instruction();
printf("请输入要进行的操作:");
scanf("%d", &choice);
while (choice<0 || choice>3)
{
printf("输入的不合法，请输入0-3选择：");
scanf("%d", &choice);
}
switch (choice)
{
case 1:
Park(gar);
break;
case 2:
total += Leave(gar);
IsPrintTotal(total);
break;
case 3:
Information(gar);
break;
case 0:
exit(0);
}
}
return 0;
}
E. c语言停车场管理系统
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define max 3
#define price 1
int b=1;
typedef struct
{
int day;
int hour;
int min;
}TIME; //时间结点
typedef struct
{
char num[10]; //车牌号
TIME time; //进入停车场的时间
int n; //进入停车场的位置
}information;
//栈结构体定义
typedef struct node
{
information data;
struct node *next;
}stacknode; stacknode *top1,*top2;
//队列结构体定义
typedef struct
{
information data;
stacknode *front,*rear;
}LQueue;LQueue *Q;
//函数声明部分/////////////////////////////////////////////////////////
stacknode *Init(); //栈的初始化
stacknode *into(stacknode *top1,LQueue *Q); //初始化车辆进入
int expenses(stacknode *p,int x,int y); //停车费用计算函数
stacknode *leave(stacknode *top1,char str[],LQueue *Q); //车辆驶出出场函数
LQueue *InitLQue(); //初始化队列函数
LQueue *wait(LQueue *q,stacknode *s); //车辆进入候车便道函数
int EmptyLQue(LQueue *q); //判断候车便道有无等待车辆函数
stacknode *out(LQueue *q); //候车区车辆出队
stacknode *LQinto(stacknode *p,stacknode *top1); //从候车便道进入停车场函数
void show(stacknode *top1); //显示停车场所有信息函数
void T_shou(LQueue *Q); //显示候车区信息
/*函数部分*/
//主函数
void main()
{
char str[10];
Q=InitLQue();
top1=Init();
top2=Init();
Q=InitLQue();
int i;
printf("\t\t\t*************************************\n");
printf("\t\t\t\t 停车场管理系统\n");
printf("\t\t\t|| 1. 车辆进入停车场 ||\n");
printf("\t\t\t|| 2. 车辆离开停车场 ||\n");
printf("\t\t\t|| 3. 显示停车场内所有车辆信息 ||\n");
printf("\t\t\t|| 4. 显示候车区内所有车辆信息 ||\n");
printf("\t\t\t|| 5. 退出 ||\n");
printf("\t\t\t*************************************\n");
while(i!=5)
{
printf("\t请输入选项1-5:");
scanf("%d",&i);
switch(i)
{
case 1:
top1=into(top1,Q);
break;
case 2:
printf("请输入离开车辆的车牌号：");
scanf("%s",str);
top1=leave(top1,str,Q);
break;
case 3:show(top1);break;
case 4:T_shou(Q);break;
case 5:exit(1);
default:printf("输入错误，请重新输入1—5:");
break;
}
}
}
/*子函数*/
//初始化
stacknode *Init()
{
stacknode *top;
top=(stacknode *)malloc(sizeof(stacknode));
top=NULL;
return top;
}
//初始化车辆进入
stacknode *into(stacknode *top1,LQueue *Q)
{
stacknode *p,*q;
time_t rawtime; //调用系统时间函数
struct tm *timeinfo; //时间结点
time(&rawtime);
timeinfo=localtime(&rawtime);
p=(stacknode *)malloc(sizeof(stacknode));
if(p==NULL)
{
printf("内存分配失败");
return top1;
}
printf("请输入进入停车场车辆的车牌号:");
scanf("%s",p->data.num);
q=top1;
while(q!=NULL)
{
if(strcmp(p->data.num,q->data.num)==0)
{
printf("车牌号输入有误，该车已进入!");
return top1;
}
q=q->next;
}
p->data.time.day=timeinfo->tm_mday;
p->data.time.hour=timeinfo->tm_hour;
p->data.time.min=timeinfo->tm_min;
p->data.n=b;
if(b>max)
{
printf("停车场已满,请在便道等候!\n");
wait(Q,p);
return top1;
}
if(top1==NULL)
{
p->next=NULL;
top1=p;
}
else
{
p->next=top1;
top1=p;
}
b++;
printf("车辆进入停车场成功，时间已经自动载入!\n");
printf("车牌为%s的汽车驶入时间为:%d号%d点%d分\n",top1->data.num,top1->data.time.day,top1->data.time.hour,top1->data.time.min);
return top1;
}
//停车费用计算函数
int expenses(stacknode *p,int x1,int x2,int x3)
{
int w;
if(x3!=0)
w=(x1*24+x2+1-(p->data.time.day*24+p->data.time.hour))*price;
else
w=(x1*24+x2-(p->data.time.day*24+p->data.time.hour))*price;
return w;
}
//车辆驶出出场函数
stacknode *leave(stacknode *top1,char str[],LQueue *Q)
{
int i,day,hour,min;
time_t rawtime;
struct tm *timeinfo;
time(&rawtime);
timeinfo=localtime(&rawtime);
day=timeinfo->tm_mday;
hour=timeinfo->tm_hour;
min=timeinfo->tm_min;
stacknode *p,*q;
if(top1==NULL)
{
printf("停车场没有车辆!\n");
return top1;
}
q=(stacknode *)malloc(sizeof(stacknode));
if(p==NULL)
{
printf("内存分配失败");
return top1;
}
q=top1;
while(q!=NULL)
{
if(strcmp(q->data.num,str)==0)
break;
q=q->next;
}
if(q==NULL)
{
printf("输入有误，该车辆不在停车场!\n");
return top1;
}
for(i=top1->data.n;i>q->data.n;i--)
{
p=(stacknode *)malloc(sizeof(stacknode));
if(p==NULL)
{
printf("内存分配失败");
return top1;
}
strcpy(p->data.num,top1->data.num);
p->data.time=top1->data.time;
p->data.n=top1->data.n-1;
top1=top1->next;
if(top2==NULL)
{
p->next=NULL;
top2=p;
}
else
{
p->next=top2;
top2=p;
}
}
top1=top1->next;
while(top2!=NULL)
{
p=(stacknode *)malloc(sizeof(stacknode));if(p==NULL){printf("内存分配失败");return top1;}
p->data.n=top2->data.n;
strcpy(p->data.num,top2->data.num);
p->data.time=top2->data.time;
p->next=top1;
top1=p;
top2=top2->next;
}
if(EmptyLQue(Q))
{
p=out(Q);
p->data.n--;
top1=LQinto(p,top1);
}
else
b--;
printf("车牌为%s的汽车驶出时间为:%d号%d点%d分\n",q->data.num,day,hour,min);
printf("车辆驶出停车场需要缴纳的费用为:%d元\n",expenses(q,day,hour,min));
return top1;
}
//队列函数初始化
LQueue *InitLQue()
{
LQueue *Q;
stacknode *p;
Q=(LQueue *)malloc(sizeof(LQueue));
p=(stacknode *)malloc(sizeof(stacknode));
p->next=NULL;
Q->front=Q->rear=p;
return Q;
}
//候车区队列入队
LQueue *wait(LQueue *q,stacknode *s)
{
s->next=NULL;
q->rear->next=s;
q->rear=s;
return q;
}
//判断候车便道有无车辆等待
int EmptyLQue(LQueue *q)
{
if(q->front==q->rear)
return 0;
else
return 1;
}
//候车区车辆出队
stacknode *out(LQueue *q)
{
stacknode *p;
p=q->front->next;
if(q->front->next==q->rear)
{
q->rear=q->front;
return p;
}
else
q->front->next=p->next;
p->next=NULL;
return p;
}
//候车队列进入停车场
stacknode *LQinto(stacknode *p,stacknode *top1)
{
p->next=top1;
top1=p;
return top1;
}
//显示停车场内所有车辆信息
void show(stacknode *top1)
{
printf(" 停车场内全部车辆信息表\n");
if(top1==NULL)
printf(" 停车场内无车!\n");
else
{
printf("车牌号 进入时间 位置\n");
while(top1!=NULL)
{
printf(" %s %d号%d点%d分 第%d位\n",top1->data.num,top1->data.time.day,top1->data.time.hour,top1->data.time.min,top1->data.n);
top1=top1->next;
}
}
}
//显示候车区的汽车信息
void T_shou(LQueue *Q)
{
LQueue *q;
q=(LQueue *)malloc(sizeof(LQueue));
q->rear=Q->rear->next;
printf(" 候车区信息\n");
if(q->front==q->rear)
printf("候车区没有车辆!\n");
else
{
printf("车牌号 进入时间\n");
while(q!=NULL)
{
printf("%s %d号%d点%d分",q->data.num,q->data.time.day,q->data.time.hour,q->data.time.min);
q->rear=q->rear->next;
}
}
}
/*时间函数
int timef()
{
int x,y;
time_t rawtime;
struct tm *timeinfo;
time(&rawtime);
timeinfo=localtime(&rawtime);
x=timeinfo->tm_mday,y=timeinfo->tm_hour;
}
time_t rawtime;
struct tm *timeinfo;
time(&rawtime);
timeinfo=locoltime(&rawtime);
timeinfo->tm_ymday,*/