c语言判断车牌号是否合法

A. 求一个基于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<<"输入有误，请重新输入：";
}
}

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

B. 如何在下列c语言停车场管理程序车辆登记环节中判断车牌号是否重复

我说一下思路，代码就不写了，你添一下很快的。
if(Enter->top<MAX)
{
//遍历比较是否有重复，如果有就break

}
else
{

}
//保存入已场的车辆

这样子就行了。

C. 用C语言确定车牌范围，也就是如何把他们一一列出来

车牌号码末尾是字母确定单双号各个地方的规定稍有不同。 北京：尾号为英文字母的机动车按双号管理。 浙江：前13个字母从A到M算单号，后13个从N到Z算双号。 济南：全运会期间按单双号限行，尾号为字母的，以最后一位阿拉伯数字为准。 详情需要以当地车管所公布的单双号执行规定执行。

D. JAVA中的判断车牌号的正则表达式是什么啊

String cph="WJ12345";
Pattern pattern = Pattern.compile("^[\u4e00-\u9fa5|WJ]{1}[A-Z0-9]{6}$");
Matcher matcher = pattern.matcher(cph);
if (!matcher.matches()) {
System.out.println("车牌号格式不对！");
}else{
System.out.println("车牌号格式正确！");
}

E. VC课设选车牌号问题，本人研究了很长时间还是不懂rand函数的用法，求帮助，本人刚入门，只能用iostream

给你个程序可以产生随机的10个大写字母和10个数字，你研究一下吧。
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main()
{
srand((unsigned int) time(NULL));
for(int i=0;i<10;i++)
{
int a=rand()%26;
char x=a+'A';
printf("%c ",x);
}
printf("\n");
for(int i=0;i<10;i++)
{
int b=rand()%10;
printf("%d ",b);
}
return 0;
}
至于怎么拼成字符串我先不教你，你自己学习下，研究试试，不难的。

F. C++车牌号市区代号判断，出问题，苏B是对的 可是速B应该不对 可它认对了，有什么办法解决，急

stringstr("人类");if((int)str.find("死")>0)
printf("okay
");//匹配成功else
printf("none
");//匹配失败//输出okay

竟然匹配了！？

*探求原因*

为什么会产生这种输出呢？
我们来想一下string.find是怎样查找的。
按字符查找！
那么，“人类”有几个字符（’’排外）呢？

printf("%d ",string("人类").length()); // 411

咦？奇怪，分明是2个，怎么有4个呢？

原来，Windows中1，中文（简体）通常使用GBK来编码的。

我们来看看“人类”是怎么编码的：

printf("%X ", "人类"[0]);
printf("%X ", "人类"[1]);
printf("%X ", "人类"[2]);
printf("%X ", "人类"[3]);
// FFFFFFC8 FFFFFFCB FFFFFFC0 FFFFFFE01234512345

请看！
“人类”的GBK编码是C8CB C0E0。

printf("%X ", "死"[0]);
printf("%X ", "死"[1]);
// FFFFFFCB FFFFFFC0123123

而“死”的编码是CBC0！
这样一来，使用string的find函数进行搜索时，”人类”能够匹配”死”的问题就瞬间搞懂了。

*问题求解*

那么，怎么解决呢？

经查询资料：
GBK分两段：ASCII段和中文段。ASCII段使用单字节，和ASCII编码保持一致；中文（及特殊符号）段使用双字节编码。在双字节段中，第一字节的范围是81–FE（也就是不含80和FF），第二字节的一部分领域在40–7E，其他领域在80–FE2。
也就是说，在GBK编码中，中文有两个字节，首字节范围81~FE，尾字节范围40~7E。
这么说来，判断一个字符（或者中文的一个字）是否为中文，只要判断其是否大于0x80即可。在判断其大于时，获取两个字节，同时向下跳一字节，进行后续判断；如果不大于，则为ASCII字符，获取一个字节。

根据以上所述，我们利用union将字符化为int型。

代码如下：

std::vector<int> stringToVecInt(const std::string &str)
{
union {
char c[2];
int i;
} convert;

// 段位清零
convert.i = 0;

std::vector<int> vec;

for (unsigned i = 0; i < str.length(); i++) {
// GBK编码首字符大于0x80
if ((unsigned)str[i] > 0x80) {
// 利用union进行转化，注意是大端序
convert.c[1] = str[i];
convert.c[0] = str[i + 1];
vec.push_back(convert.i);
i++;
} else
// 小于0x80，为ASCII编码，一个字节
vec.push_back(str[i]);
}
return vec;
}212223242526

我们使用<algorithm>里的search函数，进行子串的搜索。

bool include(const std::string &str, const std::string &msg)
{
auto sour = stringToVecInt(str);
auto find = stringToVecInt(msg);
return std::search(sour.begin(), sour.end(), find.begin(), find.end()) != sour.end();
}123456123456

测试下效果：

if (include("人类","死"))

printf("okay "); // 匹配成功
else
printf("none "); // 匹配失败
// none

G. c# textbox中要进行车牌号验证输入

1：先定义一个数组来保存车牌号的第一位：private List<string> str1 = new List<string>() { "京", "津", "冀", "晋", "蒙", "辽", "吉",
"黑", "沪", "苏", "浙", "皖", "闽", "赣", "鲁", "豫", "鄂", "湘", "粤", "桂", "琼", "渝", "川", "贵", "云", "藏", "陕", "甘", "青", "宁", "新", "学" };车牌号的第一位只能从中选择一个。
2：车牌号的第二位判断必须是大写字母： 其中strNow是textbox中的值， if (strNow.Length == 2 && !(Convert.ToInt32(strNow[1]) > Convert.ToInt32('A') - 1 && Convert.ToInt32(strNow[1]) < Convert.ToInt32('Z') + 1))
3：车牌号中剩下的后五位只能是大写字母或数字： if (strNow.Length > 2 && !(
(Convert.ToInt32(strNow[strNow.Length - 1]) > Convert.ToInt32('A') - 1 && Convert.ToInt32(strNow[strNow.Length - 1]) < Convert.ToInt32('Z') + 1) ||
(Convert.ToInt32(strNow[strNow.Length - 1]) > Convert.ToInt32('0') - 1 && Convert.ToInt32(strNow[strNow.Length - 1]) < Convert.ToInt32('9') + 1)) )
4：判断textbox中的值长度不能超过8位： if (strNow.Length > 8)

H. 编写C语言程序汽车的车牌号有7个字符为首的字符限定为";京:

/*

京A123C5 : 后五位有非规定字符!

津H88659 : 非归属地车牌!

京B1234 : 车牌号码长度错误!

京AA12343 : 车牌号码长度错误!

京A88880 : OK!

京C8865C : 后五位有非规定字符!

Press any key to continue

*/

#include<iostream>
#include<cstring>

usingnamespacestd;

#defineMAXLEN8

intCheckPlateNumber(charplatenumber[]){
	inti;
	charbelonging[5];
	if(strlen(platenumber)!=8)return1;//编码长度错误
	belonging[0]=platenumber[0];
	belonging[1]=platenumber[1];
	belonging[2]='';
	if(strcmp(belonging,"京"))return2;//车牌所属地错误
	if(platenumber[2]<'A'||platenumber[2]>'Z')return3;//首号错误
	for(i=3;i<MAXLEN;++i)
		if(platenumber[i]<'0'||platenumber[i]>'9')return4;//其他错误
	return0;
}

intmain(){
	chars[][MAXLEN+2]={"京A123C5","津H88659","京B1234","京AA12343","京A88880","京C8865C"};
	for(inti=0;i<6;++i){
		cout<<s[i]<<":";
		switch(CheckPlateNumber(s[i])){
			case0:cout<<"OK!
";break;
			case1:cout<<"车牌号码长度错误!
";break;
			case2:cout<<"非归属地车牌!
";break;
			case3:cout<<"首号错误!
";break;
			case4:cout<<"后五位有非规定字符!
";break;
			default:cout<<"其他错误!
";break;
		}
	}
	return0;
}

I. c语言判断车牌号是否合法

合法，选取数字用随机数做，字母的随机可以用ASSIC随机，然后在转化回去。

J. c语言 车牌号问题

你想到44 了吗 ？44 的时候你sum 加了2次，，
还有不懂你的int（void）是什么意思 我们都是 int main（）
当你的数字打起来后比如1 1000，你咩有考虑384 438的情况了
所以 要考虑有38 没4的情况和 有4 的情况这样2个，在考虑4 的时候，还要注意有44 444 4444之类 的出现很多次4的，就要在c[j]==4的背后跟上 break 表示跳出，不再增加。这样考虑之后你的代码应该就是正确的了 我现在 也在做这个，，具体的我觉得自己做才有感觉