c++实现ip的合法性及子网的判断

一. 源代码

说明:

源文件语言：C++

文件数：1

源文件名：ipTest.cpp

#include

#include

#include

#include

#include

#include

using namespace std;

//ipTest类定义

class ipTest{

char ip[15]; //用于存放ip地址

char ip_Temp[15]; //用于存放ip地址

char subnet_mask[18]; //用于存放subnet_mask地址

char subnet[18]; //用于存放subnet地址

char subnet_Temp[18]; //用于存放subnet地址

int mask; //用于存放mask(1的个数)

bool maskIsValid; //用于判断的个数是否合适，或是否与subnet匹配

public:

ipTest(char *,char *); //自定义初始化类函数

~ipTest(){}; //析构函数

bool ipIsValid(char *); //判断ip是否合法

bool subnetIsValid(char *); //判断子网号subnet是否合法

bool NoIllegalChar(char *); //ip,subnet地址中非法字符的判断

bool maskIsMatSubnet(int,char *);//判断mask与subnet是否匹配

void AllJudgment(); //判断mask,subnet,ip的合法性问题

void print(); //判断ip是否为子网成员，并输出判断结果

void split(char *,int *); //把单个字符地址转换为十进制数值型地址（含四段）int toBinary(int a); //十进制int型数据转换为二进制int型数据

char * toString(int *a);//把二进制int型数据转换为一个整体的二进制字符型数据};

//main主函数

int main(int argc,char *argv[]) //自动读取数据

{

//cout<<"目录地址:"<

cout<<"subnet_mask : "<

//判断段数是否输入合法

if(argc!=3) //argc表示输入的参数个数，无参数输入时，其值为,因为默认argv[0]总是有的{

cout<<"输入非法！";

return 0;

}

else

{

//先简单判断subnet/mask的长度

if(strlen(argv[1])>18)

{

cout<<"subnet/mask 输入非法！";

system("pause");

return 0;

}

//先简单判断ip的长度

if(strlen(argv[2])>15)

{

cout<<"ip 输入非法！";

system("pause");

return 0;

}

}

ipTest test(argv[1],argv[2]); //实例化类,传入两个参数

test.AllJudgment();//调用函数，判断mask,subnet,ip的合法性问题

system("pause");//系统暂停

return 0;

}

//构造函数

ipTest::ipTest(char *subnet_mask,char *ip)

{

maskIsValid=true; //设置maskIsValid默认为合法

char temp[2];//定义变量

int i,len;

len=strlen(subnet_mask);

/*******************从subnet/mask中分离出subnet地址***************/ for(i=0;i

{

this->subnet[i]=subnet_mask[i];

this->subnet_Temp[i]=subnet_mask[i];

}

subnet_Temp[i]='\0';

subnet[i]='\0';

/**************************判断mask是否为数值************************/

if((len-(i+1)<3&&len-(i+1)>0)) //判断mask是否为一/二位字节

{

if(len-(i+1)==1) //表明mask是一位

{

temp[0]=subnet_mask[i+1];

//判断字符是否为数值型字符

if(!isdigit(temp[0])) //isdigit()为库函数，可以调用

{

cout<<"mask中含有非数字的非法字符,error!"<

maskIsValid=false; //mask不是数值，则设置为false }

}

else if((len-3)==i) //表明mask是二位

{

temp[0]=subnet_mask[i+1];

temp[1]=subnet_mask[i+2];

if(!(isdigit(temp[0]) && isdigit(temp[1])))

{

cout<<"mask中含有非数字的非法字符,error!"<

maskIsValid=false;

}

}

mask=atoi(temp); //自动把数字字符转换为对应的十进制数值的函数if(mask<0 || mask>32)

maskIsValid=false;

}

else //表明mask为空或字节超出范围

{

cout<<"mask为空或超出范围,error!"<

maskIsValid=false; //若mask是三位数，则表明mask输入非法（其实为~32）}

/********************************************************************/

strcpy(this->subnet_mask,subnet_mask); //给subnet_mask赋值

strcpy(this->ip,ip); //给ip赋值

strcpy(this->ip_Temp,ip); //给ip_temp赋值

}

//判断mask,subnet,ip的合法性问题

void ipTest::AllJudgment()

{

//设置标志subnet地址是否合法的bool型变量,并调用subnetIsValid函数判断

bool subnetIsV=subnetIsValid(subnet_Temp);

//设置标记ip地址是否合法的bool型变量,并调用ipIsValid函数判断

bool ipIsV=ipIsValid(ip_Temp);

//设置标记mask与subnet地址是否匹配的bool型变量,并调用maskIsMatSubnet函数判断bool maskIsMatSub=maskIsMatSubnet(mask,subnet_Temp);

cout<

/************************判断返回的值是否为真******************/

if(!maskIsValid) //表示返回的maskIsValid是false

{

cout<<"mask输入非法！(mask为整数并在-32范围内)"<

}

else

{

cout<<"mask合法！"<

}

if(!maskIsMatSub)

{

//表示返回的maskIsMatSub是false

cout<<"mask与subnet不匹配,error!"<

}

else

{

cout<<"mask与subnet匹配!"<

}

if(!subnetIsV)

{

//表示返回的subnetIsV是false

cout<<"subnet地址非法！"<

}

else

{

cout<<"subnet地址合法！"<

}

if(!ipIsV)

{

//表示返回的ipIsV是false

cout<<"ip地址非法！"<

}

else

{

cout<<"ip地址合法！"<

}

//都合法

if(maskIsValid && maskIsMatSub && subnetIsV && ipIsV)

{

print();

}

}

//判断mask与subnet是否匹配

bool ipTest::maskIsMatSubnet(int mask,char *subnet_Temp)

{

int nbsubnet[4];//用于放十进制的各段地址

//调用把单个字符地址转换为十进制数值型地址（含四段）的函数,实现转换split(subnet_Temp,nbsubnet);

//subnet是A类地址

if(nbsubnet[0]>0 && nbsubnet[0]<127 && mask<8)

{

//mask的值小于

cout<<"mask与subnet不匹配,error!"<

return false;

}

//subnet是B类地址

if(nbsubnet[0]>=128 && nbsubnet[0]<=191 && mask<16)

{

//mask的值小于

cout<<"mask与subnet不匹配,error!"<

return false;

}

//subnet是C类地址

if(nbsubnet[0]>=192 && nbsubnet[0]<=223 && mask<24)

{

//mask的值小于

cout<<"mask与subnet不匹配,error!"<

return false;

}

//mask与subnet地址匹配

return true;

}

//把单个字符地址转换为十进制数值型地址（含四段）

void ipTest::split(char *chaddr,int *addr)

{

char ch[]=" .";

char *token,*dot[4];

int iplen=0;

token=strtok(chaddr,ch);

while(token!=NULL)

{

dot[iplen]=token;

addr[iplen]=atoi(dot[iplen]);//atoi()函数把字符数值转换为int型数值

iplen++;

token=strtok(NULL,ch);

}

}

//ip,subnet地址中非法字符的判断

bool ipTest::NoIllegalChar(char *ch)

{

int i,len=strlen(ch);

for(i=0;i

{

if(ch[i]-'0'>9 || ch[i]-'0'<0)

{

return false;

}

}

return true;

}

//判断ip是否合法

bool ipTest::ipIsValid(char *ip)

{

/******************把地址分为四段，保存在dot[]中************/

char ch[]=" .";

char ip_one[18];

strcpy(ip_one,ip);

char *token,*dot[4];

int iplen=0;

//库函数strtok(),以ch[]为界限来分段

token=strtok(ip_one,ch);

while(token!=NULL)

{

dot[iplen]=token;

iplen++;

token=strtok(NULL,ch);//此时，第一个参数必须换为NULL

}

/*****************判断地址中的段数***************************/

if(iplen!=4)

{

cout<<"地址"<

return false;

}

/***************判断地址中的'.'是否正确**********************/

int j,t=0;

for(j=0;j<=strlen(ip);j++)

{

if(ip[j]=='.')

{

t++;

}

}

if(t!=3)

{

cout<<"地址"<

return false;

}

/************************判断地址是否含有非法字符,每段地址数值溢出**********************/ int i;

for(i=0;i

{

if(!NoIllegalChar(dot[i]) || atoi(dot[i])>255)

{

if(!NoIllegalChar(dot[i])) //判断含有非法字符

cout<<"地址"<

if(atoi(dot[i])>255) //判断数值溢出

cout<<"地址"<

return false;

}

}

/*****************判断全或全的情况**************************/

int flag=1;//首先设置为非法，即全

for(i=0;i

{

if(atoi(dot[i])!=0)

{

//含有非的字段

flag=0;

}

}

if(flag==1)

{

cout<<"地址"<

return false;

}

flag=1;//首先设置为非法，即全

for(i=0;i

{

if(atoi(dot[i])!=255)

{

flag=0;

}

}

if(flag==1)

{

cout<<"地址"<

return false;

}

/**************以下判断ip地址主机号**********************/

int j1=0,j2;

//if(ip==ip_Temp)

{

//首先判断ip是哪类地址

if(atoi(dot[0])>0&&atoi(dot[0])<127) //A类ip地址

{

j1=1; //直接从开始

}

if(atoi(dot[0])==127) //为的特殊号

{

cout<<"ip地址"<

return false;

}

if(atoi(dot[0])>=128&&atoi(dot[0])<=191) //B类ip地址

{

j1=2;

}

if(atoi(dot[0])>=192&&atoi(dot[0])<=223) //C类ip地址

{

j1=3;

}

if(atoi(dot[0])>223&&atoi(dot[0])<255)

{

cout<<"请重新输入ip地址"<

return false;

}

/*

if(atoi(dot[0])==255)

{

cout<<"ip地址"<

return false;

}

*/

j2=j1; //j1用于判断全情况，j1用于判断全情况的起始下标

int flag=1;//首先设置为非法，即主机号全

for(i=j1;i

{

if(atoi(dot[i])!=0)

{

flag=0;

}

}

if(flag==1)

{

cout<<"ip地址"<

return false;

}

flag=1;//首先设置为非法，即全

for(i=j2;i

{

if(atoi(dot[i])!=255)

{

flag=0;

}

}

if(flag==1)

{

cout<<"ip地址"<

return false;

}

}

return true;

}

//判断子网号subnet是否合法

bool ipTest::subnetIsValid(char *subnet)

{

if(!ipIsValid(subnet)) //调用判断Ip的函数ipIsValid()进行判断{

return false;

}

return true;

}

//判断ip是否为子网成员，并输出判断结果

void ipTest::print()

{

char subnet_one[15],ip_one[15];

int nbip[4],nbsubnet[4],i;

strcpy(subnet_one,subnet); //把subnet地址复制给subnet_one

strcpy(ip_one,ip); //把ipt地址复制给ip_one

//split()函数把字符型的地址转换为四段int型的地址

split(subnet_one,nbsubnet); //用subnet_one而非subnet是为了保护subnet地址不被破坏split(ip_one,nbip);

for(i=0;i<4;i++)

{

nbip[i]=toBinary(nbip[i]);//将分离出来的十进制转换为二进制

nbsubnet[i]=toBinary(nbsubnet[i]);

}

char *cbip=new char[33];

char *cbsubnet=new char[33];

cbip=toString(nbip);//将二进制数组转换为位的二进制字符指针

cbsubnet=toString(nbsubnet);

for(i=0;i

{

if(cbip[i]!=cbsubnet[i])

{

cout<

//system("pause");

return;

}

}

cout<

//system("pause");

}

//十进制int型数据转换为二进制int型数据

int ipTest:: toBinary(int a)

{

//将十进制数转换为二进制数

if(a/2==0) return a%2;

return a%2+toBinary(a/2)*10; //递归调用

}

//把二进制int型数据转换为一个整体的二进制字符型数据

char * ipTest::toString(int *a)

{

//将二进制的数值数组转换个字符长的字符指针

char *temp=new char[33]; int i;

bool flag=false;

char *eight=new char(),*seven=new char(),*six=new char(),*five=new char(),*four=new char(),

*three=new char(),*two=new char(),*one=new char();

for(i=0;i<4;i++)

{

//char *itoa(int value,char *string,int radix)将整数value转换成字符串存入string,radix为转换时所用基数itoa(a[i]/10000000,eight,10); //产生每段二进制字符地址的最高位

itoa(a[i]/1000000%10,seven,10);

itoa(a[i]/100000%10,six,10);//a[i]/100000%10为每段的高第三位二进制整数

itoa(a[i]/10000%10,five,10);

itoa(a[i]/1000%10,four,10);

itoa(a[i]/100%10,three,10);

itoa(a[i]/10%10,two,10);

itoa(a[i]%10,one,10);

if(flag==true)

{

strcat(temp,eight);

}

else

{

//第一次循环时，执行此步骤；同时置flag=true保证以后循环不执行此步

strcpy(temp,eight); //第一次循环的第一次传递用连接函数

flag=true;

}

strcat(temp,seven); strcat(temp,six); strcat(temp,five);

strcat(temp,four);

strcat(temp,three); strcat(temp,two); strcat(temp,one);

}

return temp;

}