自己写的一个简单的IP组类

原创 2005年05月23日 00:30:00

//-----------------------------------文件名:ipgroup.h----------------------------------

#ifndef SUNXYIPGROUP_H
#define SUNXYIPGROUP_H
#include <string>
#include <ctype.h>
#define MAXLONGIP (255*255*255*255+255*255*255+255*255+255)
using namespace std;
class SunxyIPGroup
{
 public:
  //构造函数,提供起始IP和终止IP
  SunxyIPGroup(const char* startip,const char* endip);
        virtual ~SunxyIPGroup();
  //取得当前IP的下一个IP
        string GetNextIP(const char* curip,int offset);
  //取得起始IP
        string GetFirstIP();
  //取得终止IP
        string GetLastIP();
  //取得当前IP
  string GetCurIP();
  //相对IP总个数
        unsigned long TotalIPNum();
  //相对当前IP
        unsigned long CurIPNum();
  //取得起始IP长字
  unsigned long GetLastIPLong();
  //取得终止IP长字
  unsigned long GetFirstIPLong();
  //取得当前IP长字
  unsigned long GetCurIPLong();
  //初始化成功标志
        bool InitOK;
 private:
  //起始IP长字及其分解部分
        unsigned long startiplong;
  unsigned long startlip[4];
  string startsip[4];  
  //终止IP长字及其分解部分
        unsigned long endiplong;
  unsigned long endlip[4];
  string endsip[4];    
  //当前IP长字及其分解部分
  unsigned long curiplong;
  unsigned long curlip[4];
  string cursip[4];
  //临时分解IP缓存
  unsigned long tempiplong;
  string tempsip[4];
        unsigned long templip[4];
  //相对IP个数
  unsigned long totalipnum;  
        unsigned long curipnum;    
        //检查以字符串数组为形式的IP地址有效性,并拆分到指定的缓存内,返回值为是否拆分成功
        bool DivideIP(const char* inputip,unsigned long* inputlip,string* inputsip);
  //将指定缓存内的IP分解部分组合起来,返回组合好的以字符口串为形式的IP地址
        string AssembleIP(unsigned long inputip,unsigned long* inputlip,string* inputsip);
  //除去IP中为广播地址或网段地址等无效地址
        unsigned long ValidLongIP(unsigned long inputip);
};

//公共接口函数定义
SunxyIPGroup::SunxyIPGroup(const char* startip,const char* endip="")
{
    string stemp1(startip);
    string stemp2(endip);
 int i;
    //成员变量初始化
    InitOK=false;

 startiplong=0;
 endiplong=0;
 curiplong=0;

 totalipnum=0;
    curipnum=0;
 tempiplong=0;

    for(i=0;i<4;i++)
    {
  startlip[i]=0;
  startsip[i]="";

  endlip[i]=0;
  endsip[i]="";

  curlip[i]=0;
  cursip[i]="";

        tempsip[i]="";
        templip[i]=0;
    }
    //设置成员变量并构造IP组
    if(DivideIP(stemp1.c_str(),startlip,startsip))
    {
        startiplong=255*255*255*startlip[0]
                   +255*255*startlip[1]
                   +255*startlip[2]
                   +startlip[3];
  if(stemp2.empty ())
  {
   for(i=0;i<3;i++)
   {
    endlip[i]=startlip[i];
    endsip[i]=startsip[i];
   }
   endlip[i]=254;
   endsip[i]="254";
   endiplong=255*255*255*endlip[0]
      +255*255*endlip[1]
      +255*endlip[2]
      +endlip[3];
  }
        else if(DivideIP(stemp2.c_str(),endlip,endsip))
        {
            endiplong=255*255*255*endlip[0]
                     +255*255*endlip[1]
                     +255*endlip[2]
                     +endlip[3];

  }
        endiplong=ValidLongIP(endiplong);
        startiplong=ValidLongIP(startiplong);
        totalipnum=endiplong-startiplong+1;

        if(totalipnum>0)
        {
   //初始化成功
   curipnum=1;
   curiplong=startiplong;
   for(i=0;i<4;i++)
   {
    curlip[i]=startlip[i];
    cursip[i]=startsip[i];
   }
            InitOK=true;           
  }
        else
  {               
   //IP组可用个数为0,重新初始化
   startiplong=0;
   endiplong=0;
   curiplong=0;
   tempiplong=0;

   totalipnum=0;
   curipnum=0;

   for(i=0;i<4;i++)
   {
    startlip[i]=0;
    startsip[i]="";

    endlip[i]=0;
    endsip[i]="";

    curlip[i]=0;
    cursip[i]="";

    tempsip[i]="";
    templip[i]=0;
   }    
   InitOK=false;           
  }
    }
}

SunxyIPGroup::~SunxyIPGroup()
{
}

string SunxyIPGroup::GetNextIP(const char* curip="",int offset=1)
{
    string stemp(curip);
    if(InitOK)
    {
        //add codes here
  if(offset>=0)
  {
   if(stemp.empty ())
   {
    tempiplong=curiplong;
    curiplong+=offset;
    curiplong=ValidLongIP(curiplong);
    if(tempiplong==curiplong)
     return "";
    curipnum+=curiplong-tempiplong;    
    stemp=AssembleIP(curiplong,curlip,cursip);
   }
   else
   {   
    if(DivideIP(stemp.c_str (),curlip,cursip))
    {
     curiplong=255*255*255*curlip[0]
        +255*255*curlip[1]
        +255*curlip[2]
        +curlip[3];
     tempiplong=curiplong;
     curiplong+=offset;
     curiplong=ValidLongIP(curiplong);
     if(tempiplong==curiplong)
      return "";
     curipnum+=curiplong-tempiplong;
     stemp=AssembleIP(curiplong,curlip,cursip);
    }
   }
  }
    }
    return stemp;
}

string SunxyIPGroup::GetFirstIP()
{
    string stemp;
    stemp="";
    if(InitOK)
    {
        //add codes here
  stemp=AssembleIP(startiplong,templip,tempsip);
    }
    return stemp;
}
string SunxyIPGroup::GetLastIP()
{
    string stemp;
    stemp="";
    if(InitOK)
    {
        //add codes here
  stemp=AssembleIP(endiplong,templip,tempsip);
    }
    return stemp;
}
unsigned long SunxyIPGroup::TotalIPNum()
{
    if(InitOK)
        return totalipnum;
    return 0;
}
unsigned long SunxyIPGroup::CurIPNum()
{
    if(InitOK)
        return curipnum;
    return 0;
}

unsigned long SunxyIPGroup::GetFirstIPLong()
{
 if(InitOK)
  return startiplong;
 return 0;
}

unsigned long SunxyIPGroup::GetLastIPLong ()
{
 if(InitOK)
  return endiplong;
 return 0;
}

string SunxyIPGroup::GetCurIP ()
{
 if(InitOK)
  return AssembleIP(curiplong,curlip,cursip);
 return "";
}

unsigned long SunxyIPGroup::GetCurIPLong()
{
 if(InitOK)
  return curiplong;
 return 0;
}

//私有函数定义
bool SunxyIPGroup::DivideIP(const char* inputip,unsigned long* inputlip,string* inputsip)
{
   
    string stemp(inputip);
    bool result=false;
    int index;
    int count=0;
    long ipvalue=-1;
    if(!stemp.empty())
    {
        index=stemp.find(".");
        while(count<=3&&index>0)
        {   inputsip[count]=stemp.substr(0,index);
            ipvalue=atol(inputsip[count].c_str());
   //templip[i]=strtoul(tempsip[i].c_str());此函数用法还未查清
            if(index<stemp.length()-1&&ipvalue>=0&&ipvalue<255)
            {
                inputlip[count]=ipvalue;
                count++;
            }
            else
            {
                return result;
            }
            stemp=stemp.substr(index+1,stemp.length()-1-index);
            index=stemp.find(".");
        }
        ipvalue=atol(stemp.c_str());
  //templip[i]=strtoul(tempsip[i].c_str());此函数用法还未查清
        if(ipvalue>=0&&ipvalue<255)
        {
            inputsip[count]=stemp;
            inputlip[count]=ipvalue;
            count++;
        }
        if(count==4)
            result=true;
    }
    return result;
}

string SunxyIPGroup::AssembleIP(unsigned long inputip,unsigned long* inputlip,string* inputsip)
{
    string stemp;
    stemp="";
 int i;
    if(InitOK)
    {
  inputip=ValidLongIP(inputip);
  inputlip[0]=inputip/(255*255*255);
  inputip%=255*255*255;
  inputlip[1]=inputip/(255*255);
  inputip%=255*255;
  inputlip[2]=inputip/255;
  inputip%=255;
  inputlip[3]=inputip;
  for(i=0;i<4;i++)
  {
   char ctemp[8];
   inputsip[i]=string(ltoa(inputlip[i],ctemp,10));
   stemp=stemp+inputsip[i]+".";
  }
  stemp=stemp.substr (0,stemp.length ()-1);
  
    }
    return stemp;
}

unsigned long SunxyIPGroup::ValidLongIP(unsigned long inputip)
{
     if(inputip>endiplong)
   inputip=endiplong;
  if(inputip<startiplong)
   inputip=startiplong;
  if(inputip%255==0)
         inputip++;
  return inputip;
}
#endif

//---------------------------------ipgroup.h结束---------------------------------

演示程序:

//-------------------------------文件名:ipgrouptest.cpp--------------------------------

#include <iostream>
#include <stdlib.h>
#include "ipgroup.h"
int main(int argc,char* argv[])
{
 SunxyIPGroup ipgroup("192.168.1.1","192.168.1.200");
 cout<<"The ip group is next:"<<endl
  <<ipgroup.GetFirstIP()<<endl;
 while(ipgroup.GetCurIP()!=ipgroup.GetLastIP())
 { 
  cout<<ipgroup.GetNextIP(ipgroup.GetCurIP().c_str())<<endl;
 }
 cout<<"-----end-----"<<endl;
 system("pause");
 return 0;
}
//--------------------------------ipgrouptest.cpp结束--------------------------------------------

自己写一个简单的ArrayList

自己通过写一个简单的SimpleArrayList来加深对JDK源码中的ArrayList的理解。 构造器 如果没有对集合设定长度,这里我们默认采取长度为10作为内置数组的初始化长度。 pu...
  • humian151
  • humian151
  • 2017年09月27日 15:42
  • 142

自己写一个简单的Spring IOC容器

为了能更好的理解SpirngIOC是如何工作的,在查阅网上的资料后,自己写了一个非常简单的SpringIOC容器,使用setter方法将值注入。 本例子需要用到jdom的包:http://pan.ba...
  • lr222584
  • lr222584
  • 2017年01月26日 17:18
  • 490

自己写的String类

1:MyString.h #pragma once class myCString { public: int GetLength()const {return m_nLength;} ...
  • djb100316878
  • djb100316878
  • 2014年12月01日 08:49
  • 1255

写了一个Java的简单缓存模型

一个java简单的缓存模型
  • xxd851116
  • xxd851116
  • 2014年05月13日 15:31
  • 6368

关于使用C#编写一个简单的日志类

最近在项目中编写的log类,在博客上记录一下。 在调用的时候会按照当前时间自动生成对应的日志文件。代码如下: using System; using System.Collections.Gene...
  • carlblack1987
  • carlblack1987
  • 2017年03月24日 16:32
  • 278

写一个简单的操作系统

如果一定要找出OS最重要的核心,那就是调度器,调度器本身即可以看作一个简单的操作系统,允许以周期性或单次方式来调用任务。从底层的角度看,调度器可以看作是一个由许多不同任务共享的定时器中断服务程序,因此...
  • u010469993
  • u010469993
  • 2017年03月20日 15:30
  • 1221

自己实现一个简单版的HashMap

public class MyHashMap { //默认初始化大小 16 private static final int DEFAULT_INITIAL_CAPACI...
  • uhgagnu
  • uhgagnu
  • 2017年03月03日 18:41
  • 546

怎样自己写一个简单的操作系统

如非业务需要必要,不建议自己实现完整的计算机操作系统。重造车轮的累赘先不说。        在自己造的过程中,仿佛体验了事无巨细一切都要自己实现的艰辛,和访问底层硬件处理dirty work带来的虚假...
  • i792439187
  • i792439187
  • 2013年08月11日 20:44
  • 841

数据结构键值HashMap之自己编写简单的HashMap

通过学习HashMap数据结构,自己实现一个简单的HashMap
  • nayan3480232
  • nayan3480232
  • 2017年08月09日 00:16
  • 230

自己写一个异常类my_own_exception来感知一下异常机制

在本文中, 我自己来写一个异常类my_own_exception, 主要为了感知一下C++异常机制, 看代码: #include using namespace std; class my_own...
  • stpeace
  • stpeace
  • 2015年03月25日 22:31
  • 3570
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:自己写的一个简单的IP组类
举报原因:
原因补充:

(最多只允许输入30个字)