今天道尔智控就给我们广大朋友来聊聊停车场管理系统测试,以下9个关于的观点希望能帮助到您找到想要的答案。
停车场收费管理系统,将卡片靠近读卡机，蜂鸣器鸣叫，在软件监控界面中有读到的卡号，但不能开启道闸。
贡献用户名：【云丶摇影】 ，现在由道尔智控小编为你讲解与【停车场管理系统测试】的相关内容！
答一、读卡器鸣叫证明了读卡器没有坏
二、软件监控界面能显示卡号，并且能有车辆的图像出来，这也证明了读卡器的数据线和主板连接良好，通信正常
三、手动测试道闸的升、降、停也没问题，这证明了道闸是正常的
问题可能是:
一、该卡还没有发行为合发卡，或者过期（月租卡，储值卡）
二、该卡已发行并且有效，但是主板没有信号输出到道闸（主板有问题）
三、主板如果的信号输出，但是道闸没有反应（主板到道闸的控制线可能没有接好或者断了）
查到这里应该知道问题出在什么地方了！
如果还有不懂的可以找宝鸥停车场厂家
以上就是道尔智控小编解答贡献者：（云丶摇影）分析的关于“停车场收费管理系统,将卡片靠近读卡机，蜂鸣器鸣叫，在软件监控界面中有读到的卡号，但不能开启道闸。”的问题了，不知是否已经解决你的问题？如果没有，下一篇内容可能是你想要的答案，下面继续阐述下文用户【落花有意流水无情i】分享的“c语言停车场管理系统ppt”的一些相关疑点做出分析与解答，如果能找到你的答案，可以关注本站。
c语言停车场管理系统ppt
贡献用户名：【落花有意流水无情i】 ，现在由道尔智控小编为你讲解与【停车场管理系统测试】的相关内容！
答/*----------------------------------------------------------------
// 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<<"输入有误，请重新输入：";
}
}
以前的课设 你看看吧 纯手工的~~
上文就是道尔智控小编解答贡献者：（落花有意流水无情i）分析的关于“c语言停车场管理系统ppt”的问题了，不知是否已经解决你的问题？如果没有，下一篇内容可能是你想要的答案，现在接着继续研究下文用户【我的爱在哪里？】贡献的“九鼎智能停车场收费系统”的一些相关疑点做出分析与解答，如果能找到你的答案，可以关注本站。
九鼎智能停车场收费系统
贡献用户名：【我的爱在哪里？】 ，现在由道尔智控小编为你讲解与【停车场管理系统测试】的相关内容！
答对于停车场管理系统来说，安装在停车场中一天24小时不断的工作，所以在设备投入使用时一定要做好调试工作。对于电气设备，我们首先就需要对智能停车场系统进行通电前的检测工作，对照整个系统的接线图和各设备间的接线图，检测停车场系统的接线情况，确保整个系统接线正确、无短路、无断路的现象，通电后检查各设备的开关按钮是否灵活，检查岗亭或控制室内的总电源等。
其次，智能停车场管理系统通电正常后，对不同的进出车辆进行测试。1、对有车读卡、开闸功能的测试：在出入口处，分别对临时卡、月卡、储值卡等进行测试，停车场系统票箱的显示屏上针对不同的卡分别显示和读取不同的内容。2、对限制临时卡取卡、读卡功能的测试：在出入口控制机上进行地感限制，将铁质物体放在地感上，从票箱的取卡口处取一张临时卡，此时，道闸将进行打开，如该车未离开地感，则不能取下一张卡片，也不能读取其他卡，只有当此车辆离开时才可进行取卡，另外，如果票箱口的卡片在系统规定的时间未取走，则取消本次操作。3、无地感读卡、开闸功能测试：对于此种情况，需要人工进行发卡，停车场系统的票箱不提供吐卡功能，其余和有地感的测试步骤相同。
以上就是道尔智控小编解答(我的爱在哪里？)解答关于“九鼎智能停车场收费系统”的答案，接下来继续为你详解用户（给不了的爱）回答“（高分悬赏）C++停车场管理系统”的一些相关解答，希望能解决你的问题！
（高分悬赏）C++停车场管理系统
贡献用户名：【给不了的爱】 ，现在由道尔智控小编为你探讨与【停车场管理系统测试】的相关内容！
答#include <stdio.h>/*包含了与标准I/O库有关的变量定义和宏定义*/
#include <stdlib.h>/*文件包含所用的文件*/
#include<conio.h>
#include<io.h>
int cars[12][4]={{1234,1,1,20},{2345,1,2,15},{3456,1,3,10},
{4567,1,4,5},{0,1,5,0},{0,1,6,0},{0,2,1,0},{0,2,2,0},{0,2,3,0},
{0,2,4,0},{0,2,5,0},{0,2,6,0}};/*二维数组代表停车信息*/
void save()
{FILE *fp;
int i,j;
if((fp=fopen("car.dat","w"))==NULL)
{printf("cannot open file\n");
return;
}
for(i=0;i<12;i++)
for(j=0;j<4;j++)
if(fwrite(cars,2,1,fp)!=1)
printf("file write error\n");
fclose(fp);
getchar();
}
void car_park(void)/*停车操作*/
{int x,i,j;
printf("\n ^-^ Welcome To Our Stop! ^-^\n ");
printf(" \n\n Please,input your car number:\n\n");
printf("\n NOTICE:car number is a digit between 1000 and 9999\n Input wrong number may back to menu\n\n");
scanf("%d",&x);/*输入要停车的车牌号*/
for (i=0;i<12;i++)
if(cars[i][0]==x||x<1000||x>9999)break;
if(i!=12)
{printf("\nWrong number or it's parked !\n");
getchar();}/*如果此车号以在，打印此车已停*/
else if(i==12&&x>=1000&&x<=9999)
{for (i=0;i<12;i++)
if(cars[i][0]==0) {cars[i][0]=x;save();
printf("\n\nSUCCESS\n\n");
printf("Floor=%d,position=%d\n",cars[i][1],cars[i][2]);
printf("\n\n\nTwo times 'Enter' to end.");break;
}/*如果此车号不在，则进行停车操作*/
for (i=0;i<12;i++)
if(cars[i][0]!=0) cars[i][3]+=5;/*所有停车时间+5*/
save();/*保存信息到文件*/
}
}
void car_get(void)/*取车操作*/
{
int i,y;float paid;int a;
printf("\n Get Car\n\n\n Input your car number:\n\n\n\n");
printf("\n NOTICE:car number is a digit between 1000 and 9999\n Wrong load would have no cue\n\n");
scanf("%d",&y);/*输入要取车的车牌号*/
for(i=0;i<12;i++)
{
for(i=0;i<12;i++)
if(cars[i][0]==y)
{
cars[i][0]=0;/*取车后车牌号清零*/
paid=0.2*cars[i][3]/5;/*计算停车费用*/
printf("\n Printf out the paid(1--YES 2 or any key--NO)\n\n\n");
scanf("%d",&a);
{
switch(a)
{
case 1:
printf("\n\n\nThe paid is %8.2fyuan\n",paid);/*打印停车费用*/
cars[i][3]=0;/*时间清零*/
save();
break;
case 2:
printf("Good bye");
cars[i][3]=0;/*时间清零*/
save();
break;
default: break;
}
}
}else;break;
}
if(i==12)printf("\nThe number is not in the park!\n");/*如果此车不在，打印号码不在*/
}
void printfdata()/*停车信息*/
{int i,j;
FILE *fp;
fp=fopen("car.dat","r");/*打开文件"car.dat"*/
printf(" \n Number Floor Position Time\n");
for(i=0;i<12;i++)
{for(j=0;j<4;j++)
{fread(cars,2,1,fp);/*读文件*/
printf(" %6d",cars[i][j]);
}printf("\n");
}
fclose(fp);/*关闭文件"car.dat"*/
}
void save();
void car_park(void);
void car_get(void);
void printfdata();
char readcommand();
void initialization();
void main()
{
char c;
while(1)
{
initialization(); /*初始化界面*/
c=readcommand(); /*读取停车场状况*/
clrscr();
switch(c)
{
case 'p': car_park(); break;/*停车操作*/
case 'P': car_park(); break;/*停车操作*/
case 'g': car_get(); break;/*取车操作*/
case 'G': car_get(); break;/*取车操作*/
case 'd': printfdata();
printf("\n\n please press 'Enter' to continue\n");
scanf("%c",&c); break;/*停车信息*/
case 'D': printfdata(); /*停车信息*/
printf("\n\n rreupklfdkplease press 'Enter' to continue\n");
scanf("%c",&c); break;
case 'e': printf("\n\n\n\n Press 'Enter' to continue.");exit(0); break;
case 'E': printf("\n\n\n\n Press 'Enter' to continue.");exit(0); break;
default : printf("ERROR! Press 'Enter' to continue."); getchar(); break;
}
}
}
/********************************************************************************/
void initialization() /*初始函数*/
{
int i;
getchar();
clrscr();
gotoxy(0,0);
for(i=1;i<=80;i++) printf("\1\3");
for(i=1;i<=80;i++) printf("\2");
gotoxy(15,6);
printf("THIS IS OUR CAR PART MANAGE SYSTEM!");
gotoxy(15,9);
printf("NAME: GuanYoufu");
gotoxy(15,10);
printf("NUM: 1111111327");
gotoxy(15,11);
printf("GRADE: 2006");
gotoxy(15,12);
printf("CLASS: caiyan0603");
gotoxy(1,14);
printf("\n********************************************************************************\n");
printf(" 1. Park car--p 2. Get car--g 3. Date of parking--d 4.Exit--E");
printf("\n\n********************************************************************************\n");
}
char readcommand() /*选择函数*/
{
char c;
while((c!='p')&&(c!='P')&&(c!='g')&&(c!='G')&&(c!='d')&&(c!='D')&&(c!='e')&&(c!='E'))
{
printf("Input p,g,d,e choose\n");
c=getchar();
printf("\n");break;
}
return c;
}
根据自己得需要修改一下吧
上文就是道尔智控小编解答贡献者：（给不了的爱）回答的关于“（高分悬赏）C++停车场管理系统”的问题了，不知是否已经解决你的问题？如果没有，下一篇内容可能是你想要的答案，现在接着继续概述下文用户【诺曦】解答的“停车场管理系统包括哪些”的一些相关疑点做出分析与解答，如果能找到你的答案，可以关注本站。
停车场管理系统包括哪些
贡献用户名：【诺曦】 ，现在由道尔智控小编为你解答与【停车场管理系统测试】的相关内容！
答停车场管理系统属于弱电智能化工程的一个重要组成部分，比较系统和专业，和视频监控、楼宇对讲、防盗报警、音视频公共广播等统共同组成了智能化工程项目，停车场系统管理着整个建筑群区域里的车辆进出与收费管理，保证停车场系统正常稳定运行至观重要，所以在停车场施工完成之后一定要进行全面的检查与调试，那么停车场管理系统试运行的步骤有哪些呢？
一 、停车场系统设备线路的检查
停车场系统属于机电设备，是通过各种线缆将电器与电子元器件连接起来的，用强电与弱电部分，建议从强电检查起，看供电电压是否为220v，即一根火线和一根零线，最好用万用表检测，因为在施工的时候，有很多三相线，有可能都是2根火线、电压就是80V,非常重要、几乎都是这样的原因烧坏了电气设备，接着检查线是否按照电路图接错，弱电部分通讯线CAN总线正负级，弱电设备线连接是否正确，都检查好无误之后、就可电试车了。
二、停车场设备通电检查
在检查完线路无误后，就可以通电了。通电之后，检查所有机电是否都正常启动，通电正常，弱电系统通讯功能正常，并以联网。
三、停车场系统设备参数设置
整改停车场系统都可以正常通电之后，就可以根据实际的需求进行相关设备参数的设置了，具体的有收费管理系统设置，车位数、通讯协议端口、管理员权限、收费标准；出入口道闸控制机（票箱）设置：地址码设置、车辆检测器灵敏度。
四．停车场系统运行检测
设备参数设置好之后，将停车场系统进行式运行，通过进出检测整个系统，道闸开启、票箱出卡、刷卡计费、图像记录、数据查询等功能，运行过程中，遇到问题，及时调整，直到系统可以稳定 高效的完成停车进出收费管理就可以正式投入使用了。
以上就是道尔智控小编解疑贡献者：（诺曦）解答的关于“停车场管理系统包括哪些”的问题了，不知是否已经解决你的问题？如果没有，下一篇内容可能是你想要的答案，现在接着继续祥解下文用户【酒醉无人巷】回答的“停车场管理系统SDK都支持那些系统？”的一些相关疑点做出分析与解答，如果能找到你的答案，可以关注本站。
停车场管理系统SDK都支持那些系统？
贡献用户名：【酒醉无人巷】 ，现在由道尔智控小编为你分析与【停车场管理系统测试】的相关内容！
答停车场管理系统SDK安装包基本的系统是都支持的，win7\XP的。不过易泊的SDK安装包正在测试win8和win10的系统，估计很快也会支持了
上文就是道尔智控小编解答贡献者：（酒醉无人巷）分析的关于“停车场管理系统SDK都支持那些系统？”的问题了，不知是否已经解决你的问题？如果没有，下一篇内容可能是你想要的答案，接下来继续简述下文用户【我能够弯腰】分析的“停车场管理系统程序设计流程图”的一些相关疑问做出分析与解答，如果能找到你的答案，可以关注本站。
停车场管理系统程序设计流程图
贡献用户名：【我能够弯腰】 ，现在由道尔智控小编为你分析与【停车场管理系统测试】的相关内容！
答要想把停车场管理系统做到完美，在编写程序代码时候就得注重细节，根据目前停车场智能化的不断提高，在技术人员的不断努力下改写历史，在每一次技术升级都要做到精确无误。
北京同业兴创停车场管理系统最重要的功能包括以下几方面：录入车辆信息，包含进入的时间、车牌、品牌；实现显示功能，即显示停车场中剩余位置的信息、车停时长；实现计费功能；实现保存功能，即将输入的车辆信息保存到指定的磁盘文件中；实现加载功能，即加载磁盘文件中保存的内容。
代码如下：
#include<iostream.h>
#include<malloc.h>
#define STACK_INIT_SIZE 3//存储空间初始分配量
#define PRICE 2
//^^^^^^^^^^^车辆信息^^^^^^^^^^^^^^^^^
struct Car//车辆信息，栈
{
int num;//车牌号
int time[2];//存放到达和离开的时间,time[0]代表到达时间，time[1]代表离开时间
};
struct Node//队列信息，便道
{
Car car;
Node * next;
};
//^^^^^^^^^^^^^停车场栈^^^^^^^^^^^^^
typedef struct StopStack//停车场栈
{
Car * base;
Car * top;
int stacksize;//当前已分配的存储空间，以元素为单位
}StopStack;
//^^^^^^^^^^^^便道队列^^^^^^^^^^^^^
typedef struct BiandaoQueue//便道队列
{
Node * front;//队头指针
Node * rear;//队尾指针
}BiandaoQueue;
//***********************便道初始化——构造空队列S*************************
int InitQueue(BiandaoQueue &Q)
{
Q.front=(Node *)malloc(sizeof(Node));
if(!Q.front)
{
cout<<endl<<"OVERFLOW!";
return(0);
}
Q.front->next=NULL;//Q.front是一个空结点
Q.rear=Q.front;
return 1;
}
//*****************车离开时仍在便道上**************************
void DeBiandao(BiandaoQueue &Q,Car &e)
{
Node *p,*q;
p=Q.front;
while (p->next->car.num!=e.num)
{
p=p->next;
}
q=p->next;
p->next=q->next;
if(q==Q.rear) Q.rear=p;//若删除的是队尾元素
e=q->car;
free(q);
}
//*****************车辆编号**************************
void StackBianhao(StopStack &S)
{
cout<<"该车在停车场的位置为："<<S.top-S.base<<endl;
cout<<"======================"<<endl<<endl<<endl;
}
void QueueBianhao(BiandaoQueue &Q)
{
int i=0;
Node *q;
q=Q.front;
while(q!=Q.rear)
{
q=q->next;
i++;
}
cout<<"该车在便道的位置为："<<i<<endl;
cout<<"======================"<<endl<<endl<<endl;
}
//***********************出便道——出队*************************
//出队 车辆e开出停车场
int DeQueue(BiandaoQueue &Q,Car &e)//若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK否则返回ERROR
{
if(Q.front==Q.rear)//判空
{
cout<<endl<<"If it was deleted, it's empty !";
return 0;
}
Node *p;
p=Q.front->next;
e=p->car;//用e返回
Q.front->next=p->next;//修改头指针始终指向队首元素
if(Q.rear==p) Q.rear=Q.front;//特殊情况处理空队！
free (p);
return 1;
}
//***********************出停车场——出栈*************************
//出栈 车辆e开出停车场
int pop(StopStack &S,Car &e)
{
if(S.top==S.base)
{
return 0;
}//栈空-停车场空
S.top--;
e=*(S.top);
return 1;
}
//***********************进入便道——入队*************************
//入队 插入元素e为新的栈顶元素 车e进入便道
int EnQueue(BiandaoQueue &Q,Car e)//插入元素e为Q的新的队尾元素
{
Node *p;
p=(Node *)malloc(sizeof(Node));
if(!Q.front)
{
cout<<endl<<"OVERFLOW!";
return(0);
}//分配失败
p->car=e;
p->next=NULL;//生成新结点
Q.rear->next=p;//插入队尾
Q.rear=p;//修改队尾指针指向队尾
return 1;
}
//***********************进入停车场——入栈*************************
//入栈 插入元素e为新的栈顶元素 车e进入停车场
void push(StopStack &S,Car e)
{
*(S.top)=e;
S.top++;
}
//***********************判断便道上是否有车*************************
bool EmptyQueue(BiandaoQueue Q)
{
if(Q.front==Q.rear)
return true;
else
return false;
}
//***********************判断车离开时所在场所*************************
bool EmptyStack(StopStack S);
int LeaveWhere(Car e,StopStack S,BiandaoQueue Q )
{
if(EmptyStack(S))//特别注意，这句话不能省略
return -1;
else
{
Car *p;
p=S.base;
while(p->num!=e.num && p!=S.top-1)//!特别注意，此处不是S.top而是S.top-1
p++;
if(p->num==e.num)//此时车在停车场，return 1
return 1;
else//此时车在便道或不存在
{
Node *q;
q=Q.front->next;
while(q->car.num!=e.num && q!=Q.rear)
q=q->next;
if(q->car.num==e.num)//此时车在便道，return 0
return 0;
else
return -1;//此车不存在
}
}
}//return 1:在停车场
//return 0:在便道
//return -1:还未停车
//***********************判断车车是否已存在*************************
bool EmptyStack(StopStack S);
bool CarAbsence(Car e,StopStack S,BiandaoQueue Q )
{
if(EmptyStack(S))//特别注意，这句话不能省略
return false;
else
{
Car *p;
p=S.base;
while(p->num!=e.num && p!=S.top-1)//!特别注意，此处不是S.top而是S.top-1
p++;
if(p->num==e.num)//此时车在停车场，return 1
return true;
else//此时车在便道或不存在
{
Node *q;
q=Q.front;
while(q->car.num!=e.num && q!=Q.rear)
q=q->next;
if(q->car.num==e.num)//此时车在便道，return 0
return true;
else
return false;//此车不存在
}
}
}//return 1:车已在
//return 0:还未停车
//***********************判断停车场上是否有车*************************
bool EmptyStack(StopStack S)
{
if(S.top==S.base)
return true;
else
return false;
}
//***********************判断停车场是否满*************************
//判断是否满了
bool StackOver(StopStack &S)
{
if((S.top-S.base)>=S.stacksize)
{
cout<<"停车场已满，请驶进便道。"<<endl;
return true;
}
else
return false;
}
//***********************停车场初始化——构造空栈S*************************
int InitStack(StopStack &S)
{
S.base=(Car *)malloc(STACK_INIT_SIZE*sizeof(Car));
if(!S.base)
{ cout<<"OVERFLOW!"<<endl;
return (0);
}//if(!S.base) 存储分配失败
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return (1);
}
//***********************main函数******************************
int maxtime=0;//当前最终活动时间
void main()
{
int i,j,time;
char a;
Car e,e1,e2;
StopStack S1,S2;
BiandaoQueue Q;
InitStack(S1);
InitStack(S2);
InitQueue(Q);//初始化
cout<<"^^^^^^^^^^^^^^停车场管理系统^^^^^^^^^^^^^^^^"<<endl;
cout<<"^ 1.输入 ^"<<endl;
cout<<"^ 0.退出 ^"<<endl;
cout<<"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"<<endl;
cout<<"请选择(1或0)"<<endl;
cin>>i;
while(i!=0&&i!=1)
{
cout<<"对不起，你的选择有误，请重新选择！"<<endl;
cout<<"^^^^^^^^^^^^^^停车场管理系统^^^^^^^^^^^^^^^^"<<endl;
cout<<"^ 1.输入 ^"<<endl;
cout<<"^ 0.退出 ^"<<endl;
cout<<"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"<<endl;
cout<<"请选择(1或0)"<<endl;
cin>>i;
}
while(i!=0)//选择1时
{
cout<<"请输入车辆信息(g代表到达，l代表离开):"<<endl;
cout<<"g或l 车牌号 时间"<<endl;
cin>>a>>e.num;
//-----------------------------------------------进入----------------------------------------- if(a=='g')//进入
{
cin>>e.time[0];
if(CarAbsence(e,S1,Q ))//该车已停
cout<<"对不起，该车已停，请重新输入！"<<endl;
else if(e.time[0]<maxtime)//若输入时间有误
cout<<"对不起，你输入的到达时间有误，请重新输入！"<<endl;
else if(!StackOver(S1))//如果停车场未满
{
push(S1,e);//e进入停车场
maxtime=e.time[0];//更新当前最终活动时间
StackBianhao(S1);//车辆在停车场的编号
}
else//停车场满，要停在便道上
{
EnQueue(Q,e);//进入便道
maxtime=e.time[0];//更新当前最终活动时间
QueueBianhao(Q);//车辆在便道的编号
}
}//if结束，进入完成
//-------------------------------------------------离开-------------------------------- else if(a=='l')//离开
{
cin>>e.time[1];
time=e.time[1];//另一辆车开进停车场的时间与该车离开停车场的时间相同,用time记录
if(LeaveWhere(e,S1,Q )==1)//如果离开时车在停车场
{
if(e.time[1]<maxtime)//若输入时间有误
cout<<"对不起，你输入的到达时间有误，请重新输入！"<<endl;
else
{
j=0;
e2=*(S1.top);
while(e2.num!=e.num)
{
pop(S1,e1);
e2=e1;
push(S2,e1);//把e前边的车暂时压入另一个栈中
j++;//记录暂时开出去的车的数量
}//while循环结束时，e2就是离开的车
maxtime=time;//更新当前最终活动时间
e2.time[1]=time;
cout<<"该车在停车场内停留的时间为："<<e2.time[1]-e2.time[0]<<endl;
cout<<"应缴纳费用为："<<(e2.time[1]-e2.time[0])*PRICE<<endl;
pop(S2,e);
j=j-1;
while(j!=0)
{
pop(S2,e);
push(S1,e);//再把暂时存在栈S2中的车按原来的次序压入栈S1中
j--;
}
if(!EmptyQueue(Q))//如果便道上有车
{
DeQueue(Q,e);
maxtime=e.time[0];//更新当前最终活动时间
e.time[0]=time;//另一辆车开进停车场的时间与该车离开停车场的时间相同
push(S1,e);//把停在便道上的头一辆车开进停车场
}
}
}
else if(LeaveWhere(e,S1,Q )==0)//如果离开时车在便道
{
if(e.time[1]<maxtime)//若输入时间有误
cout<<"对不起，你输入的到达时间有误，请重新输入！"<<endl;
else
{
DeBiandao(Q,e);
e.time[1]=time;
cout<<"该车在停车场内停留的时间为："<<e.time[1]-e.time[0]<<endl;
cout<<"应缴纳费用为："<<"0"<<endl;
}
}
else//如果该车不存在
cout<<"对不起，要离开的车辆不存在，请重新输入！"<<endl;
}//else结束，离开完成
//-----------------------------------------------输入有误，输入的不是g或l--------------------------------------------------
else
cout<<"对不起，您的输入有误，请重新输入！"<<endl;
//---------------------------------------------------------------------------------------- cout<<"^^^^^^^^^^^^^^停车场管理系统^^^^^^^^^^^^^^^^"<<endl;
cout<<"^ 1.输入 ^"<<endl;
cout<<"^ 0.退出 ^"<<endl;
cout<<"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"<<endl;
cout<<"请选择(1或0)"<<endl;
cin>>i;
while(i!=0&&i!=1)
{
cout<<"对不起，你的选择有误，请重新选择！"<<endl;
cout<<"^^^^^^^^^^^^^^停车场管理系统^^^^^^^^^^^^^^^^"<<endl;
cout<<"^ 1.输入 ^"<<endl;
cout<<"^ 0.退出 ^"<<endl;
cout<<"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"<<endl;
cout<<"请选择(1或0)"<<endl;
cin>>i;
}
}//while循环结束
}//main()函数结束
上文就是道尔智控小编解答贡献者：（我能够弯腰）解答的关于“停车场管理系统程序设计流程图”的问题了，不知是否已经解决你的问题？如果没有，下一篇内容可能是你想要的答案，现在接着继续叙说下文用户【蓝狼战队】分享的“智慧停车管理系统是怎么做的？”的一些相关疑点做出分析与解答，如果能找到你的答案，可以关注本站。
智慧停车管理系统是怎么做的？
贡献用户名：【蓝狼战队】 ，现在由道尔智控小编为你讲解与【停车场管理系统测试】的相关内容！
智慧停车是指将卫星定位、GIS、物联网、互联网、无线通信、电子支付、大数据、云计算等技术综合应用于城市停车的规划、建设、运营、管理，以及查询、预约与导航服务，实现停车泊位资源的实时更新、查询、预约与导航服务一体化，实现多元化电子支付的便捷化，实现城市治理的智能化、信息化和决策的科学化，实现城市泊位资源利用率的最大化、停车泊位经营利润的最大化和停车服务的最优化。
以上就是道尔智控小编解答(蓝狼战队)贡献关于“智慧停车管理系统是怎么做的？”的答案，接下来继续为你详解用户（与友热情）贡献“c语言停车场管理系统课程设计”的一些相关解答，希望能解决你的问题！
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,*/
本文关于[停车场管理系统测试]的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
