精华内容
下载资源
问答
  • 检测IP参考地址_正则表达式 检测IP_正则表达式办法 1,检测IP算法,接口说明也如下图。 /* *brief *param: the ip address *return value: if susscess,0 is returned,or 1 is returned on error. */ int ...

    转载地址1  转载地址2  转载地址3 

    检测IP参考地址_正则表达式

    检测IP_正则表达式办法

    1,检测IP算法,接口说明也如下图。

    /*
    *brief 
    *param: the ip address
    *return value: if susscess,0 is returned,or 1 is returned on error.
    */
    int checkValidIP(const char *ipaddr)
    {
        char str[31], temp[31];
        int a, b, c, d;
    
        if (sscanf(ipaddr, "%d.%d.%d.%d ", &a, &b, &c, &d) == 4 && a >= 0 && a <= 255 && b >= 0 && b <= 255 && c >= 0 && c <= 255 && d >= 0 && d <= 255)
        {
            sprintf(temp, "%d.%d.%d.%d", a, b, c, d); //把格式化的数据写入字符串temp
            if (strcmp(temp, ipaddr) == 0)
            {
                return 0; //success
            }
            else
            {
                return 1;
            }
        }
        else
        {
            return 1;
        }
    
        return 0;
    }

    2,检测Mac算法,接口说明也如下图。

    MAC(Media Access Control或者Medium Access Control)地址,意译为媒体访问控制,或称为物理地址、硬件地址,用来定义网络设备的位置。在OSI模型中,第三层网络层负责 IP地址,第二层数据链路层则负责 MAC地址。MAC地址是网卡决定的,是固定的。因此一个主机会有一个MAC地址,而每个网络位置会有一个专属于它的IP地址。为确保MAC地址的唯一性,以太网卡制造商将MAC地址固化到网卡中。地址的前半部分(24位)标识网卡的制造商,由IEEE分配,称为OUI(组织唯一标识符);地址的后半部分由网卡制造商为其网卡分配一个唯一的编号。MAC地址为电脑网卡的物理地址,每个网卡拥有全球唯一的MAC,以示区别。格式通常为6个字节的二进制代码(以6组16进制数表示,共占6个字节),格式为XX-XX-XX-XX-XX-XX 或者 XX:XX:XX:XX:XX:XX 比如: ED-DD-4D-45-5A-9F

    在一些使用MAC地址的场合中,需要对MAC地址进行合法性检测,以下提示C和JAVA两种检测方法,原理基本一致,都是使用正则表达式进行匹配:

    匹配模式:"^([A-Fa-f0-9]{2}[-,:]){5}[A-Fa-f0-9]{2}$"

    ^ 代表开头

    [A-Fa-f0-9]{2}  表示由两个16进进字符制组成 

    [-,:] 分隔符可能 为 " : "或 " - "

    {5} 前面由5个类似格式的字段组成,即 5个 XX- 或 XX:

    [A-Fa-f0-9]{2} 表示由两个16进进字符制组成结尾

    /*
    *brief 
    *param: pattern,正则表达式字符串;value,the mac address.
    *return value: if susscess,0 is returned,or 1 is returned on error.
    */
    int ereg(char *pattern, char *value)
    {
        int r, cflags = 0;
        regmatch_t pm[10];
        const size_t nmatch = 10;
        regex_t reg;
    
        r = regcomp(&reg, pattern, cflags);
        if (r == 0)
        {
            r = regexec(&reg, value, nmatch, pm, cflags);
        }
        regfree(&reg);
    
        return r;
    }
    /*
    *brief check whether the mac address is format-right
    *param: the mac address
    *return value: if susscess,0 is returned,or 1 is returned on error.
    */
    int isValidMac(char *macaddr)
    {
        int r;
        char reg[1024] = {"^[a-f0-9A-F]\\([a-f0-9A-F]\\:[a-f0-9A-F]\\)\\{5\\}[a-f0-9A-F]$"};
        r = ereg(reg, macaddr);
        return r;
    }
    

     

    #include <stdio.h>
    #include <sys/types.h>
    #include <regex.h>
     
     
    int is_valid_mac_addr(char* mac) { 
       
    	int status;
    	const char * pattern = "^([A-Fa-f0-9]{2}[-,:]){5}[A-Fa-f0-9]{2}$";
    	const int cflags = REG_EXTENDED | REG_NEWLINE;	
    	
    	char ebuf[128];
    	regmatch_t pmatch[1];
    	int nmatch = 10;
    	regex_t reg;
     
     
    	status = regcomp(&reg, pattern, cflags);//编译正则模式
    	if(status != 0) {
    		regerror(status, &reg, ebuf, sizeof(ebuf));
    		fprintf(stderr, "regcomp fail: %s , pattern '%s' \n",ebuf, pattern);
    		goto failed;
    	}
     
    	status = regexec(&reg, mac, nmatch, pmatch,0);//执行正则表达式和缓存的比较,
    	if(status != 0) {
    		regerror(status, &reg, ebuf, sizeof(ebuf));
    		fprintf(stderr, "regexec fail: %s , mac:\"%s\" \n", ebuf, mac);
    		goto failed;
    	}
     
    	printf("[%s] match success.\n", __FUNCTION__);
    	regfree(&reg);
    	return 0;
     
    failed:
    	regfree(&reg);
    	return -1;
    }
    

    3,相关库函数—— regcomp regexec讲解 参考链接

    https://blog.csdn.net/tanghaiyu777/article/details/65444332

    https://www.cnblogs.com/274914765qq/p/4574367.html

    https://www.cnblogs.com/lifan3a/articles/7536749.html

    https://www.cnblogs.com/catgatp/p/8052556.html

    4,正则表达式介绍:

    http://www.runoob.com/regexp/regexp-syntax.html

    展开全文
  • IP地址合法性及子网判断

    热门讨论 2009-06-25 14:37:45
    判断时要考虑全面,比如以下IP地址均不合法:  123..2.1  123.23$.2.1  123.2345.2.1  123.23.45.2.1 C)判断掩码的合法性。 D)在IP地址合法的前提下,判断ip_addr是否属于子网subnet。 E)输出...
  • 分析:首先我们要知道IP地址(IPV4)的条件: (除去特殊的主机和广播地址) 1、IP地址只有三个 ’ . ',如果不是三个点,就不是IP地址 2、例如:A.B.C.D A不能为0,且每一位都不能大于255 3、所以要用一个函数单独...

    分析:首先我们要知道IP地址(IPV4)的条件:
    (除去特殊的主机和广播地址)
    1、IP地址只有三个 ’ . ',如果不是三个点,就不是IP地址
    2、例如:A.B.C.D
    A不能为0,且每一位都不能大于255
    3、所以要用一个函数单独对 **’ . '**进行判断
    4、特别说明一下isdigit函数,主要用于检查其参数是否为十进制数字字符,C语言中要加上头文件<ctype.h>
    代码如下:

    //如何判断合法的IP地址, 尽可能考虑各种情况(面试题)
    //判断IPV4的地址是否合法的程序
    
    #include<stdio.h>
    #include<ctype.h>
    
    static int PointNum(const char* str)
    {
    	int count = 0;
    	if (str == NULL)
    	{
    		return 0;
    	}
    	while (*str != '\0')
    	{
    		if (*str == '.')
    		{
    			count++;
    		}
    		str++;
    	}
    	return count;
    }
    bool IsIP(char* str)
    {
    	int num = 0;
    	if (str == NULL || str[0] == '0')//IP地址起始不能为0
    	{
    		return false;
    	}
    	if (PointNum(str) != 3)//IP地址只有3个'.'
    	{
    		return false;
    	}
    	while (*str != '\0')
    	{
    		if (isdigit(*str))
    		{
    			num = num * 10 + (*str) - '0';
    		}
    		else if (*str != '.' || num > 255)
    		{
    			return false;
    		}
    		else
    		{
    			num = 0;
    		}
    		str++;
    	}
    	if (num > 255)//最后一个数据不在进循环,所以最终处理尾部数据
    		return false;
    	return true;
    }
    int main()
    {
    	char *str[] = { "192.188.1.2", "256.3.4.1", "0.1.2.3", "123.256.3.4", "198.164.23.259" };
    	for (int i = 0; i < sizeof(str) / sizeof(str[0]); i++)
    	{
    		if (IsIP(str[i]))
    		{
    			printf("%s 是合法的IP\n", str[i]);
    		}
    		else
    		{
    			printf("%s 不是合法的IP\n", str[i]);
    		}
    	}
    	return 0;
    }
    
    展开全文
  • 1.输入一个IP地址字符串(支持16进制和10进制),判断ip是否合法,例如ip为“192.1.0.1”返回ture,ip为“266.266.266.1”,返回false。 程序思路 1、要把ip地址分隔开,当然是用“.”分割。 2、ip地址有十进制和16...

    1.输入一个IP地址字符串(支持16进制和10进制),判断ip是否合法,例如ip为“192.1.0.1”返回ture,ip为“266.266.266.1”,返回false。

    程序思路

    1、要把ip地址分隔开,当然是用“.”分割。
    2、ip地址有十进制和16进制,该如何兼容,先判断是否是16进制,如果是,则转换成整型,如果不是,直接转换为整型
    3、再进行判断是否在0-255之间,是否是4个数

    部分程序解释

    一、.分割字符串

    	//1.分割字符串
    		p = strtok(str1, split);
    

    解释:
    char* strtok (char* str,constchar* delimiters );
    函数功能:
      切割字符串,将str切分成一个个子串
    函数参数:
      str:在第一次被调用的时间str是传入需要被切割字符串的首地址;在后面调用的时间传入NULL。
     delimiters:表示切割字符串(字符串中每个字符都会 当作分割符)。
    函数返回值:
    当s中的字符查找到末尾时,返回NULL;
    如果查不到delimiter所标示的字符,则返回当前strtok的字符串的指针。

    二、

    // 2、字符串为16进制,转换为十进制
    				/* strtol converts string to long integer */
    				num = strtol(p, NULL, 16);
    

    他的作用就是把,字符串转为长整型

    long int strtol(const char *nptr,char **endptr,int base);

    这个是函数原型,nptr就是我们的字符串,endptr是结束符(NULL就是\0),base是进制数,默认的0(10进制)

    整体工程代码

    程序代码如下

    //程序代码如下
    //```
    #include "stdafx.h"
    #define  _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    
    
    
    //检查字符是否是在16进制字母中
    static  int  isString_Hex(char *p)
    {
    
    	int  ret = 0;
    	if (p == NULL)
    	{
    		ret = 0;
    	}
    	else
    	{
    
    		while (*p)
    		{
    
    			if (((*p >= 'a') && (*p <= 'f')) || ((*p >= 'A') && (*p <= 'F')))
    			{
    				ret = 1;
    				break;
    			}
    			else
    			{
    				ret = 0;
    			}
    			p++;
    		}
    	}
    
    
    	return ret;
    
    }
    
    
    /***
    ***:checkIP
    ***Function:判断ip地址是否合法
    ***Input:  str   IP地址
    ***Output: TRUE 合法
    FALSE 不合法
    ****/
    int  checkIP(const  char * str)
    {
    	//const char * str 表示其指针所指向的内容是只读的,不能被修改
    	//ip地址默认采用IPv4的点分十进制法,合法地址为0.0.0.0-255.255.255.255
    	int  ret = 0;
    	const char * split = ".";
    	char *str1;
    	char * p;
    	int  seg_num = 0;
    	int  ip[10] = { 0 };
    	long  num = 0;
    	int i = 0;
    	int correct = 0;
    
    
    
    	/*
    	char* strtok (char* str,constchar* delimiters );
    	函数功能:
    	  切割字符串,将str切分成一个个子串
    	  函数参数:
    	    str:在第一次被调用的时间str是传入需要被切割字符串的首地址;在后面调用的时间传入NULL。
    		 delimiters:表示切割字符串(字符串中每个字符都会 当作分割符)。
    		 函数返回值:
    		 当s中的字符查找到末尾时,返回NULL;
    		 如果查不到delimiter所标示的字符,则返回当前strtok的字符串的指针。
    		 */
    
    	if (str == NULL)
    	{
    		printf("str is null\n");
    		ret = 0;
    	}
    	else
    	{
    		str1 = (char*)malloc(strlen(str) + 1);
    		strcpy(str1, str);
    		//1.分割字符串
    		p = strtok(str1, split);
    		while (p != NULL) {
    
    			//2.判断字符串是否为16进制,若为16进制返回10进制,否则直接转换为整型
    			if (isString_Hex(p))
    			{
    				//字符串为16进制,转换为十进制
    				/* strtol converts string to long integer */
    				num = strtol(p, NULL, 16);
    
    
    			}
    			else
    			{
    				//字符串为10进制
    				num = strtol(p, NULL, 10);
    			}
    			printf("p:%s		", p);
    			ip[seg_num] = num;
    			printf("ip[seg_num]=%ld\n", ip[seg_num]);
    			seg_num++;
    			p = strtok(NULL, split);
    
    		}
    
    		if (seg_num == 4)
    		{
    			for (i = 0; i < seg_num; i++)
    			{
    				if ((ip[i] >= 0) && (ip[i] <= 255))
    					correct++;
    			}
    			if (correct == 4)
    			{
    				ret = 1;
    			}
    			else
    			{
    				ret = 0;
    			}
    
    
    		}
    		else
    		{
    			ret = 0;
    		}
    
    	}
    
    	return ret;
    }
    
    
    
    int  main()
    {
    
    	char str[] = "f.e.a.c";
    	int  ret = 0;
    	ret = checkIP(str);
    	if (ret == 0)
    	{
    		printf("IP  无效\n");
    	}
    	else if (ret == 1)
    	{
    		printf("IP  有效\n");
    	}
    
    
    	printf("hello\n");
    	system("pause");
    	return  0;
    }
    
    

    运行结果如图:

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 世界上并没有完美的程序,...所有的IP地址划分为 A,B,C,D,E五 A地址1.0.0.0~126.255.255.255; B地址128.0.0.0~191.255.255.255; C类地址192.0.0.0~223.255.255.255; D地址224.0.0.0~239.255.255.255; .

    世界上并没有完美的程序,但是我们并不因此而沮丧,因为写程序就是一个不断追求完美的过程。

    题目描述
    请解析IP地址和对应的掩码,进行分类识别。要求按照A/B/C/D/E类地址归类,不合法的地址和掩码单独归类。
    
    所有的IP地址划分为 A,B,C,D,E五类
    
    A类地址1.0.0.0~126.255.255.255;
    
    B类地址128.0.0.0~191.255.255.255;
    
    C类地址192.0.0.0~223.255.255.255;
    
    D类地址224.0.0.0~239.255.255.255;
    
    E类地址240.0.0.0~255.255.255.255
    
    
    私网IP范围是:
    
    10.0.0.0~10.255.255.255
    
    172.16.0.0~172.31.255.255
    
    192.168.0.0~192.168.255.255
    
    
    子网掩码为二进制下前面是连续的1,然后全是0。(例如:255.255.255.32就是一个非法的掩码)
    注意二进制下全是1或者全是0均为非法
    
    注意:
    1. 类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类,也不属于不合法ip地址,计数时可以忽略
    2. 私有IP地址和A,B,C,D,E类地址是不冲突的
    
    输入描述:
    多行字符串。每行一个IP地址和掩码,用~隔开。
    
    输出描述:
    统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数,之间以空格隔开。
    
    示例1
    输入
    复制
    10.70.44.68~255.254.255.0
    1.0.0.1~255.0.0.0
    192.168.0.2~255.255.255.0
    19..0.~255.255.255.0
    输出
    复制
    1 0 1 0 0 2 1
    

    解决:

    public class test {
        private static String w3 = "((([.][2][0-5][0-5])|([.][1][0-9][0-9])|([.][1-9][0-9])|([.][0-9])){3})";
        private static String w2 = "((([.][2][0-5][0-5])|([.][1][0-9][0-9])|([.][1-9][0-9])|([.][0-9])){2})";
    
        private static String w1 = "((([.][2][0-5][0-5])|([.][1][0-9][0-9])|([.][1-9][0-9])|([.][1-9])))";
        private static String w = "((([2][0-5][0-5])|([1][0-9][0-9])|([1-9][0-9])|([0-9])))";
    
        private static String regA = "(([1][0-2][0-6])|([1-9][0-9])|([0-9]))" + w3;
        private static String regB = "(([1][2][8-9])|([1][3-8][0-9])|([1][9][0-1]))" + w3;
        private static String regC = "(([1][9][2-9])|([2][0-2][0-3]))" + w3;
        private static String regD = "(([2][2][4-9])|([2][3][0-9]))" + w3;
        private static String regE = "(([2][4][0-9])|([2][5][0-5]))" + w3;
    
        private static String regS1 = "([1][0])"+w3;
        private static String regS2 = "([1][7][2]).(([1][6-9])|([2][0-9])|([3][0-1]))"+w2;
        private static String regS3 = "([1][9][2]).([1][6][8])"+w2;
    
        private static String regY = "([2][5][5])(.[0]){3}|([2][5][5]).([2][5][5])(.[0]){2}|([2][5][5])([.][2][5][5]){2}.[0]";
        private static String regN = "([2][5][5])([.][2][5][5]){3}|([0](.[0]){3})";
    
        private static String reg0 = w + "([.][0]){3}";
        private static String reg1 = "255" + w1 + "([.][0]){2}";
        private static String reg2 = "255.255" + w1 + "([.][0])";
        private static String reg3 = "255.255.255" + w1;
    
        private static Pattern pattern0 = Pattern.compile(reg0);
        private static Pattern pattern1 = Pattern.compile(reg1);
        private static Pattern pattern2 = Pattern.compile(reg2);
        private static Pattern pattern3 = Pattern.compile(reg3);
    
        private static Pattern patternY = Pattern.compile(regY);
        private static Pattern patternN = Pattern.compile(regN);
    
        private static Pattern patternA = Pattern.compile(regA);
        private static Pattern patternB = Pattern.compile(regB);
        private static Pattern patternC = Pattern.compile(regC);
        private static Pattern patternD = Pattern.compile(regD);
        private static Pattern patternE = Pattern.compile(regE);
    
        private static Pattern patternS1 = Pattern.compile(regS1);
        private static Pattern patternS2 = Pattern.compile(regS2);
        private static Pattern patternS3 = Pattern.compile(regS3);
    
    
        private static boolean hasA (String ip) {
            return patternA.matcher(ip).matches();
        }
    
        private static boolean hasB (String ip) {
            return patternB.matcher(ip).matches();
        }
    
        private static boolean hasC (String ip) {
            return patternC.matcher(ip).matches();
        }
    
        private static boolean hasD (String ip) {
            return patternD.matcher(ip).matches();
        }
    
        private static boolean hasE (String ip) {
            return patternE.matcher(ip).matches();
        }
    
        private static boolean hasS (String ip) {
            boolean b1 = patternS1.matcher(ip).matches();
            boolean b2 = patternS2.matcher(ip).matches();
            boolean b3 = patternS3.matcher(ip).matches();
            return b1 || b2 || b3;
        }
    
        private static boolean hasY (String ip) {
            boolean bY = patternY.matcher(ip).matches();
            boolean bN = patternN.matcher(ip).matches();
            if (bY) {return true;}
            if (bN) {return false;}
            return pan(ip);
        }
    
    
    
        private static boolean pan (String ip) {
            String[] ss = ip.split(".");
            if (ss.length == 4) {
                boolean b = pattern0.matcher(ip).matches();
                if (b) {
                    return dan(ss[0]);
                }
                b = pattern1.matcher(ip).matches();
                if (b) {
                    return dan(ss[1]);
                }
                b = pattern2.matcher(ip).matches();
                if (b) {
                    return dan(ss[2]);
                }
                b = pattern3.matcher(ip).matches();
                if (b) {
                    return dan(ss[3]);
                }
            }
            return false;
        }
    
        private static boolean dan (String s) {
            if (null != s && !"".equals(s)) {
                int n = Integer.valueOf(s);
                return has0end(to2(n));
            }
            return false;
        }
    
        private static String to2 (int n) {
            if (n != 0) {
                StringBuilder sb = new StringBuilder();
                foo(n, sb);
                sb.reverse();
                return sb.toString();
            }
            return "";
        }
    
        private static void foo (int tmp, StringBuilder sb) {
            while (true) {
                if (tmp == 1) {
                    sb.append(1);
                    break;
                } else {
                    sb.append(tmp%2);
                    tmp /= 2;
                }
            }
        }
    
        private static boolean has0end (String s) {
            if (!"".equals(s)) {
                char[] chars = s.toCharArray();
                int len = chars.length;
                for (int i=0; i<len; i++) {
                    if('1' == chars[i] && i!=0 && '0' == chars[i-1])  {
                        return false;
                    }
                }
            }
            return true;
        }
    
        private static String getCount (String...ips) {
            List<String> ls = Arrays.asList("A", "B", "C", "D", "E", "O", "S");
            Map<String, Integer> map = new HashMap<>(16);
            for(String str: ips) {
                String[] ss = str.split("~");
                String ip1 = ss[0];
                String ip2 = ss[1];
    
                if (!hasY(ip2)) {
                    mapCount("O", map);
                    continue;
                }
    
                boolean flag = true;
                if (hasA(ip1)) {
                    mapCount("A", map);
                    flag = false;
                } else if (hasB(ip1)) {
                    mapCount("B", map);
                    flag = false;
                } else if (hasC(ip1)) {
                    mapCount("C", map);
                    flag = false;
                } else if (hasD(ip1)) {
                    mapCount("D", map);
                    flag = false;
                } else if (hasE(ip1)) {
                    mapCount("E", map);
                    flag = false;
                }
    
                if (hasS(ip1)) {
                    mapCount("S", map);
                    flag = false;
                }
    
                if (flag) {
                    mapCount("O", map);
                }
    
    
    
            }
            StringBuilder sb = new StringBuilder();
            ls.forEach(s -> {
                Integer cnt = map.get(s);
                sb.append(null == cnt?0:cnt).append(" ");
            });
            return sb.toString();
        }
    
        private static void mapCount (String key, Map<String, Integer> map) {
            if (map.containsKey(key)) {
                map.put(key, map.get(key)+1);
            } else {
                map.put(key, 1);
            }
        }
    
        public static void main(String[] args) {
            String[] ss = {"10.70.44.68~255.254.255.0",
                    "1.0.0.1~255.0.0.0",
                    "192.168.0.2~255.255.255.0",
                    "19..0.~255.255.255.0"};
            String re = getCount(ss);
            System.out.println(re);
        }
    }
    

    得出结果:

    1 0 1 0 0 2 1
    

    题目有歧义,并没有说明要先判断子网掩码,如果是平等的,ABCDE类型与私有IP有重合的,既然说明了他们之间没有冲突,那么就会出现IP既属于ABCDE中的一种又属于私有的情况,亦或是给一个优先级,优先判断一种类型。

    在这里插入图片描述

    展开全文
  • 正则表达式验证合法IP地址

    千次阅读 2019-06-30 12:13:43
    IPv4地址 最初设计互联网络时,为了便于寻址和层次化构造网络,每个IP地址包括两个标识码...Internet委员会定义了5种IP地址类型以适应不同容量的网络,即A~E。 类别 IP地址范围 最大网络数 最大主机...
  • 要求:1)以命令行格式运行:ip_test subnet/mask ...4) 在IP地址合法的前提下,判断ip_addr是否属于子网subnet 5)输出命令行中的IP是否合法,掩码是否合法(可适当给出不合法原因)以及ip_addr是否属于子网subnet。
  • IP地址ABC

    千次阅读 2020-07-27 18:14:59
    以下表列出留用的内部寻址地址 A 10.0.0.0 --10.255.255.255 B 172.16.0.0--172.31.255.255 C类 192.168.0.0--192.168.255.255 1. A类地址 ⑴ A类地址第1字节为网络地址,其它3个字节为主机地址。另外第1个字节...
  • IP地址分类

    2010-06-30 15:25:00
    1.IP地址分类IP地址分为网络地址和主机地址二个部分,A地址前8位为网络地址,后24位为主机地址,B地址16位为网络地址,后16位为主机地址,C类地址前24位为网络地址,后8位为主机地址,网络地址范围如下表所示:...
  • 【iOS work】判断ip地址是否合法

    千次阅读 2015-10-09 19:44:10
    写一个程序输出以下ip列表(21.45.34.112,0.25.132.143,20.268.56.10)是否是合法ip。(注:ip第一位不能为0,每一位不能超过255)   答案:   #import &lt;Foundation/Foundation.h&gt; //创建...
  • C++判断IP地址字符串的合法

    万次阅读 2017-08-02 18:28:54
    目前的解决方法可以归为以下: 1、自己动手写:以'.'将IP字符串分割成子串,再依次判断每个子串的每个字符是否都是数字,最后转换成值,判断是否在0~255的范围。 /* 功能: 判断IP地址是否有效 接口函数: ...
  • IP地址的分类

    2014-04-07 10:48:22
    以下表列出留用的内部寻址地址 A 10.0.0.0 --10.255.255.255 B 172.16.0.0--172.31.255.255 C类 192.168.0.0--192.168.255.255 1. A类地址 ⑴ A类地址第1字节为网络地址,其它3个字节为主机地
  • 接下来用C语言来判断输入ip的过程中是不是正确的输入,主要是判断以下几种情况是不合法的: 1、同时出现两个小数点或者以小数点开头 2、输入的小数点大于3 3、小数点之间的数字不在0~255之间 //把str字符串中,第一...
  • 识别有效的IP地址和掩码并进行分类

    千次阅读 2017-07-08 16:39:39
    题目描述 请解析IP地址和对应的掩码,...所有的IP地址划分为 A,B,C,D,E五: A地址1.0.0.0~126.255.255.255; B地址128.0.0.0~191.255.255.255; C类地址192.0.0.0~223.255.255.255; D地址224
  • 1,检测IP算法,接口说明也如下图。   /* *brief *param: the ip address *return value: if susscess,0 is returned,or 1 is returned on error. */ int checkValidIP(const char...
  • 私有地址(Private address)属于非注册地址,专门为组织机构内部使用。 ... 以下表列出留用的内部寻址地址  A 10.0.0.0 --10.255.255.255  B 172.16.0.0--172.31.255.255  C类
  • Android 判断IP地址及端口是否正确

    万次阅读 2021-03-17 18:18:53
    一、前言 在进行网络编程时,端口或者...a) IP地址长度判断 b) 切割字符串,是否能够被分为四段 c) 每段是否为数字 d) 每个数字是否在0 ~ 255之间 三、参考代码 private boolean isNetPort(int port) { boolean flag
  • IP地址详解

    千次阅读 2013-10-27 13:29:59
    一、IP地址概念    IP地址就是给每个连在Internet网的主机分配一个在全世界范围内唯一的标示符。IP地址(英语:Internet Protocol Address)是一种... 在 TCP/IP协议中,IP地址是以二进制数字形式出现的,共32bit
  • 公用IP地址及私用IP地址

    千次阅读 2013-12-26 15:13:22
    IP 位址可分為兩大,一是公用 IP 位址 (Public IP) ,另一是私用 IP 位址 (Private IP) ,所謂公用 IP 位址,是於 互聯網 上 IP 位址,也就是說,擁有這個 IP 的電腦或網路設備在 互聯網 就有合法的「地址」,...
  • IP地址的规划和设计方法(二)

    千次阅读 2015-08-01 08:55:13
    五,IP地址规划方法  (1)IP地址规划的基本步骤  网络地址规划需要按以下6步进行:  a)判断用户对网络与主机数的需求;  b)计算满足用户需求的基本网络地址结构;  c)计算地址掩码;  d)计算网络地址; ...
  • IP地址的基础知识 在TCP/IP通信中,IP地址用于识别主机和路由器。 1.IP地址的定义 IPv4地址为32位,IPv6地址为128位。(以下以IPv4为例) 将32位的IP地址分为4组,每组8位,每组间用“.”隔开,再将每组数转为...
  • BUPT OJ101 IP地址

    千次阅读 2014-03-11 20:37:37
    最低的IP地址是0.0.0.0,最高的IP地址是255.255.255.255。 PS :方便起见,认为形似00.00.00.00的IP地址也是合法的。   输入格式 第一行是一个整数T,代表输入还剩下T行 以下的T行,每行
  • IP地址与CIDR

    2020-04-21 23:57:21
    CIDR采用各种长度的"网络前缀"来代替分类地址中的网络号和子网号,其格式为:IP地址 = {<网络前缀>,<主机号>}。为了区分网络前缀,通常采用"斜线记法"(CIDR记法),即IP地址/网络前缀所占比特数。例如...
  • 如何计算IP地址

    千次阅读 2015-07-02 09:40:22
    IP地址是一个32位的二进制数,它由网络ID和主机ID两部份组成,用来在网络中唯一的标识的一台计算机。网络ID用来标识计算机所处的网段;主机ID用来标识计算机在网段中的位置。IP地址通常用4组3位十进制数表示,中间用...
  • 九度OJ 1203 IP地址

    2015-05-05 19:52:30
    输入: 输入的第一行包括一个整数n(1输出: 可能有多组测试数据,对于每组数据,如果IP地址合法则输出"Yes!”,否则输出"No!”。样例输入:2 255.255.255.255 512.12.2.3 样例输出: Yes! No!
  • IP地址大全之IPV4版

    千次阅读 2009-03-07 03:14:00
    IP 地 址我们平时说的IP地址,也就是IPv4,一般分合法IP地址和私有IP地址。其中,合法IP地址主要应用于Internet,用来实现Internet上的主机访问,而私有IP地址应用于局域网,用来实现局域网中计算机之间的互相...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,746
精华内容 16,298
关键字:

以下合法的c类ip地址是