c停车管理系统源码_c语言停车场管理系统源代码_Exploit_中国信息安全门户网站（老牌黑客网站）

文章目录：

1、C语言停车场管理系统
2、用C语言编一个停车场管理系统
3、c语言停车场管理系统
4、急求C++车辆管理系统源代码！

C语言停车场管理系统

/*----------------------------------------------------------------

// 文件名：模拟停车场问题.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_CONUTTIME_COUNTendl; //输出所停时间信息

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_CONUTTIME_COUNTendl;

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)

{

cintmpstr;

getchar();

if(tmpstr.length()MAX_PLATE)

{

for(i=0;i10;i++)

license_plate[i] = tmpstr.c_str()[i];

flag = 0;

}

else

cout"输入有误，请重新输入：";

}

以前的课设你看看吧纯手工的~~

用C语言编一个停车场管理系统

/*初始化停车场信息，初始状态为第一层已经停有4辆车,

* 其车位号依次为1—4 , 停车时间依次为20, 15, 10 , 5

void Init(struct Garage gar[][6])

{

int i, j;

/*给所有的车位的层号，车位号初始化，停车时间初始化为0，停车位全都初始化为空*/

for (i=0; i2; i++)

{

for (j=0; j6; 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; i4; 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; i2; i++)

{

for (j=0; j6; 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; i6; 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; i6; 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; i2; i++)

{

for(j=0; j6; 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; i2; i++)

{

for (j=0; j6; 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 (choice0 || choice3)

{

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;

}

c停车管理系统源码_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(bmax)

{

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;iq-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,*/

急求C++车辆管理系统源代码！

可查可运行，注释详细，呵呵

#includeiostream

#includestring

using namespace std;

#define MAX 2 //停车场车位数

#define price 0.5//每分钟收取的费用

typedef struct time

{

int hour;

int min;

}Time;//定义时间结点

typedef struct node

{

string num;

Time reach;

Time leave;

}CarNode;//定义每辆车的牌号，进入时刻，开出时刻

typedef struct NODE

{

CarNode *stack[MAX+1];

int top;

}SeqStackCar;//用栈定义，构造停车场

typedef struct car

{

CarNode *data;

struct car *next;

}QueueNode;//用队列结点定义，构造停车场外的单个等候车辆

typedef struct Node

{

QueueNode *head;

QueueNode *rear;

}LinkQueueCar;//用队列定义，构造停车场外的等候便道

void InitStack(SeqStackCar *); //初始化堆栈函数声明

int InitQueue(LinkQueueCar *); //初始化队列头结点函数声明

int Arrival(SeqStackCar *,LinkQueueCar *); //车辆进入时登记函数声明

void Leave(SeqStackCar *,SeqStackCar *,LinkQueueCar *);//车辆离开时函数声明

void List(SeqStackCar,LinkQueueCar); /*查看停车场内车辆情况及

便道上车辆情况的函数声明*/

void main( )

{

SeqStackCar Enter,Temp;//初始栈，中转栈

LinkQueueCar Wait;//便道队列

int a;

InitStack(Enter);

InitStack(Temp);

InitQueue(Wait);//初始化

while(1)

{

cout"********************************************************************"endl;

cout" 欢迎光临停车场！";

cout"(*^__^*) ！";

coutendl"车辆到达登记-请按 1";

cout" 车辆离开登记-请按 2"endl;

cout"车辆停靠查询-请按 3";

cout" 退出系统 -请按 4"endl;//系统选项设置

while(1)

{

cina;

if(a=1a=4) break;

else coutendl"请选择： 1~4.";

}

switch(a)

{

case 1:Arrival(Enter,Wait);break; //调用入停车场函数

case 2:Leave(Enter,Temp,Wait);break;//调用出停车场函数

case 3:List(Enter,Wait);break; //调用查看函数

case 4:exit(0);

default: break;

}

void InitStack(SeqStackCar *s) //堆栈初始化

{

s-top=0;

s-stack[s-top]=NULL;

}

int InitQueue(LinkQueueCar *Q)//队列初始化

{

Q-head=new QueueNode ;

if(Q-head!=NULL)

{

Q-head-next=NULL;

Q-rear=Q-head;

return 1;

}

else return -1;

}

void PRINT(CarNode *p,int room) //输出离开停车场的车辆情况

{

int A,B,C,D;

cout"\n车辆离开的时间:";

cinp-leave.hourp-leave.min;

cout"离开车辆的车牌号为:";

coutp-num;

coutendl"其到达时间为: "p-reach.hour":"p-reach.min;

cout"离开时间为: "p-leave.hour":"p-leave.min;

A=p-reach.hour;

B=p-reach.min;

C=p-leave.hour;

D=p-leave.min;

coutendl"应交费用为: "((C-A)*60+(D-B))*price"元"endl;

cout"车辆离开登记完毕!"endl;

cout"*********************************************************************"endl;

delete p;

}

int Arrival(SeqStackCar *Enter,LinkQueueCar *W)

{

CarNode *p;

QueueNode *t;

p=new CarNode;

cout"*********************************************************************"endl;

cout"车辆到达登记开始："endl;

coutendl"请输入车牌号:";

cinp-num;

if(Enter-topMAX)//如果车位未满则进停车场内

{

Enter-top++;

coutendl"车辆在车场第"Enter-top"位置.";

coutendl"车辆到达时间:";

cinp-reach.hourp-reach.min;

coutendl"车辆到达登记完毕!"endl;

cout"*********************************************************************"endl;

Enter-stack[Enter-top]=p;// p是那辆汽车

return 1;

}

else //如果车位已满，则停靠在便道上

{

cout"*********************************************************************"endl;

coutendl"该车须在便道等待!有车位时进入车场"endl;

t=new QueueNode ;

t-data=p;

t-next=NULL;

W-rear-next=t;

W-rear=t;

return 1;

}

void Leave(SeqStackCar *Enter,SeqStackCar *Temp,LinkQueueCar *W)

{

int room;

CarNode *p,*t;

QueueNode *q;

if(Enter-top0)

{

while(1)

{

cout"*********************************************************************"endl;

cout"车辆离开登记开始:"endl;

coutendl"请输入车在车场的位置/1--"Enter-top"/:";

cinroom;

if(room=1room=Enter-top) break;

}

while(Enter-toproom)//从停车场堆栈向中转堆栈移动车辆，直到要离开车辆的位置停止

{

Temp-top++;

Temp-stack[Temp-top]=Enter-stack[Enter-top];

Enter-stack[Enter-top]=NULL;

Enter-top--;

}

p=Enter-stack[Enter-top];

Enter-stack[Enter-top]=NULL;

Enter-top--;

while(Temp-top=1)//将中转堆栈中的车辆移回停车场堆栈

{

Enter-top++;

Enter-stack[Enter-top]=Temp-stack[Temp-top];

Temp-stack[Temp-top]=NULL;

Temp-top--;

}

cout"*********************************************************************"endl;

cout"车辆离开登记结算："endl;

PRINT(p,room);

if((W-head!=W-rear)Enter-topMAX)

{

q=W-head-next;

t=q-data;

Enter-top++;

coutendl"便道的"t-num"号车进入车场第";

coutEnter-top"位置."endl;

cout"请输入"t-num"号车进入车场的时间:";

cint-reach.hourt-reach.min;

W-head-next=q-next;

if(q==W-rear) W-rear=W-head;

Enter-stack[Enter-top]=t;

delete q;

}

else coutendl"便道里没有车"endl;

}

else coutendl"车场里没有车."endl;

}

void List1(SeqStackCar *S) //查看停车场内车辆情况的函数定义

{

int i;

if(S-top0)

{

cout"********************************************************************"endl;

coutendl"车场内部车辆停靠情况:"endl;

coutendl"位置到达时间车牌号"endl;

for(i=1;i=S-top;i++)

{

couti;

cout" "S-stack[i]-reach.hour":"S-stack[i]-reach.min;

cout" "S-stack[i]-numendl;

}

else coutendl"车场里没有车"endl;

cout"********************************************************************"endl;

}

void List2(LinkQueueCar *W) //查看便道上停靠车辆情况的函数定义

{

QueueNode *p;

p=W-head-next;

if(W-head!=W-rear)

{

cout"********************************************************************"endl;

coutendl"便道停靠车辆情况:"endl;

while(p!=NULL)

{

coutendl"车辆牌号：";

coutp-data-numendl;

p=p-next;

}

else coutendl"便道里没有车."endl;

cout"********************************************************************"endl;

}

void List(SeqStackCar S,LinkQueueCar W) //车辆列表显示函数

{

int flag,tag;

flag=1;

while(flag)

{

cout"********************************************************************"endl;

cout"车辆停靠查询开始："endl;

coutendl"请选择 1|2|3:"endl;

cout"1.车场列表"endl"2.便道列表"endl"3.返回主菜单"endl;

while(1)

{

cintag;

if(tag=1||tag=3) break;

else coutendl;

cout"请选择 1~3:";

}

switch(tag)

{

case 1:List1(S);

cout"车辆停靠查询结束!"endl;break;

case 2:List2(W);

cout"车辆停靠查询结束!"endl;break;

case 3:flag=0;break;

default: break;

}

}cout"********************************************************************"endl;

};

5条大神的评论

回复

访客 2022-07-12 下午 11:42:08

numendl; p=p-next;}} else coutendl"便道里没有车."endl; cout"*******************************

回复

访客 2022-07-12 下午 06:10:54

sempty == 0){gar[i][j].time += 5;}}}}/*停车*/void Park(struct Garage gar[][6]){int i;char num[8];printf("请输入车牌号：");s

回复

访客 2022-07-12 下午 02:32:22

t"*********************************************************************"endl; Enter

回复

访客 2022-07-12 下午 06:01:49

k[i]-reach.min; cout" "S-stack[i]-numendl;}}else coutendl"车场里没有车"endl; cout"**************************************************

回复

访客 2022-07-12 下午 02:00:27

-next=q-next; if(q==W-rear) W-rear=W-head; Enter-stack[Enter-top]=t; delete q;}else coutendl"便道里没有车"endl;}else coutendl"车场里没有车."endl; }void

一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30

c停车管理系统源码_c语言停车场管理系统源代码

文章目录：

C语言停车场管理系统

用C语言编一个停车场管理系统

c语言停车场管理系统

急求C++车辆管理系统源代码！

相关文章

白云边酒5星真伪鉴定_白云边酒四星多少钱

怎样鉴定红宝石的真伪_如何鉴定真假红宝石

浪琴鉴定真伪查询图片_浪琴识别真伪查询

新塔防三国是不是服务器关了_新塔防三国开服时间

5条大神的评论

发表评论