投稿
  1. 首页
  2. sql

停车场管理系统C语言程序

12寸照片尺寸 • 2023-3-22 • sql • 阅读 21

停车场管理系统C语言程序,第1张

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

struct Garage

{

char carnum[8]/*车牌号*/

int lay//层号

int garagenum/*车位号*/

int time/*停车时间*/

int isempty/*该车位是否为空,1表示空，0表示有车*/

}

/*打印使用说明*/

void Instruction()

{printf(" 停车场管理系统使用说明\n")

printf(" 停车请输入 1 取车请输入 2\n")

printf(" 查看全部车辆的信息请输入 3 退出请输入 0 \n")

}

/*初始化停车场信息，初始状态为第一层已经停有4辆车, * 其车位号依次为1-4 , 停车时间依次为20, 15, 10 , 5 */

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

{

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

for (i=0i<2i++)

{ for (j=0j<6j++)

{ 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=0i<4i++)

{ gar[0][i].isempty =0 }

strcpy(gar[0][0].carnum, "0000")/*初始化的车牌号*/

gar[0][0].time = 20

strcpy(gar[0][1].carnum,

"1111")gar[0][1].time = 15

strcpy(gar[0][2].carnum, "2222")

gar[0][2].time = 10

strcpy(gar[0][3].carnum, "3333")

gar[0][3].time = 5}

/*新停入的汽车后，将在此之前的所有车的停车时间加5*/

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

{ int i, jfor (i=0i<2i++)

{ for (j=0j<6j++)

{ if (gar[i][j].isempty == 0)

{gar[i][j].time += 5

}

}

}

}

/*停车*/

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

{ int ichar num[8]

printf("请输入车牌号：")

scanf("%s", num)

for (i=0i<6i++)

{ 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=0i<6i++)

{

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=0i<2i++) { for(j=0j<6j++)

{ 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, jchar num[8]

double charge = 0

printf("请输入要取的车牌号：")

scanf("%s", num)

for (i=0i<2i++)

{ for (j=0j<6j++)

{ 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

}

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

// 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=0break

}

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=0i<10i++)

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

flag = 0

}

else

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

}

}

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

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/sjk/6426173.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
12寸照片尺寸 12寸照片尺寸 一级用户组
0 0
上一篇 2023-03-22
下一篇 2023-03-22

发表评论

登录后才能评论

评论列表（0条）

保存