CIDR 表示法与子网掩码：读懂 /8 到 /32
192.168.1.0/24 里斜杠后面那个数字，数的是位数，不是地址数。它说明一个 IPv4 地址的 32 位里有多少位属于网络，剩下的位归主机。CIDR 表示法（CIDR notation）的内容，基本上就是这一句话。
其余结论全都从这句话里掉出来。/24 剩下 8 个主机位，所以这个网段装 2⁸ = 256 个地址；/26 剩下 6 位，装 64 个。每还给主机侧一位，网段就翻一倍；每多占一位，网段的数量就翻一倍。能分给设备的数量通常比总数少 2，因为第一个地址是网络地址，最后一个是广播地址。/26 给你 62 个可用主机地址，不是 64 个。
有两个前缀是故意打破这条「减 2」规则的。反掩码（wildcard mask）也不是子网掩码，尽管这两个值天天被互相粘进对方的字段。如果你只想要某一个网段的答案，子网掩码计算器直接给结果；这篇文章讲的是不靠工具怎么算到那里。
CIDR 表示法到底在说什么
子网掩码本身也是一个 32 位数字，写法和地址一样。它的二进制位是一串 1 后面跟一串 0：1 标记网络位，0 标记主机位。把 /26 完整展开就是：
11111111.11111111.11111111.11000000
255 . 255 . 255 . 192把每个八位组换算回十进制，得到的就是 255.255.255.192。CIDR 表示法只数前导 1 的个数，而不是把三十二位全写出来。192.168.1.0/26 和 192.168.1.0 255.255.255.192 是同一句话的两种语法，设备要哪一种，完全取决于你正在敲的那条命令。
数位数就是全部诀窍。/8、/16、/24 正好落在八位组边界上，所以它们的十进制形式看着整齐：255.0.0.0、255.255.0.0、255.255.255.0。但表示法本身并不要求这样。/22 和 /27 同样合法，它们从八位组中间切开，产生 255.255.252.0 这类看着莫名其妙的掩码，写成二进制就不奇怪了。
这套表示法取代的是分类地址。1993 年之前，地址的前几位决定了它的大小：A 类占一个 /8，B 类一个 /16，C 类一个 /24，中间没有任何档位。一个有 300 台主机的机构，要么申请一个 B 类、浪费掉 65,000 多个地址，要么拿两个 C 类网段、多背一条路由。CIDR（RFC 1519，后由 RFC 4632 修订）解开了这层绑定：前缀跟着地址一起走，网段大小可以是任意 2 的幂。分类地址在认证考试和旧文档里还会出现，但自 1993 年 CIDR 落地起，分类路由就已经作废了：决定网络在哪里结束的是掩码，不是第一个八位组。
子网掩码速查表：/8 到 /32
表里的最后一列是有意加上的：它给出通用公式 2ⁿ − 2 算出来的结果，除了最下面两行，其余各行都与真实可用数一致。
| 前缀 | 子网掩码 | 反掩码 | 地址总数 | 可用主机数 | 套 2ⁿ − 2 得到 |
|---|---|---|---|---|---|
| /8 | 255.0.0.0 | 0.255.255.255 | 16777216 | 16777214 | 16777214 |
| /9 | 255.128.0.0 | 0.127.255.255 | 8388608 | 8388606 | 8388606 |
| /10 | 255.192.0.0 | 0.63.255.255 | 4194304 | 4194302 | 4194302 |
| /11 | 255.224.0.0 | 0.31.255.255 | 2097152 | 2097150 | 2097150 |
| /12 | 255.240.0.0 | 0.15.255.255 | 1048576 | 1048574 | 1048574 |
| /13 | 255.248.0.0 | 0.7.255.255 | 524288 | 524286 | 524286 |
| /14 | 255.252.0.0 | 0.3.255.255 | 262144 | 262142 | 262142 |
| /15 | 255.254.0.0 | 0.1.255.255 | 131072 | 131070 | 131070 |
| /16 | 255.255.0.0 | 0.0.255.255 | 65536 | 65534 | 65534 |
| /17 | 255.255.128.0 | 0.0.127.255 | 32768 | 32766 | 32766 |
| /18 | 255.255.192.0 | 0.0.63.255 | 16384 | 16382 | 16382 |
| /19 | 255.255.224.0 | 0.0.31.255 | 8192 | 8190 | 8190 |
| /20 | 255.255.240.0 | 0.0.15.255 | 4096 | 4094 | 4094 |
| /21 | 255.255.248.0 | 0.0.7.255 | 2048 | 2046 | 2046 |
| /22 | 255.255.252.0 | 0.0.3.255 | 1024 | 1022 | 1022 |
| /23 | 255.255.254.0 | 0.0.1.255 | 512 | 510 | 510 |
| /24 | 255.255.255.0 | 0.0.0.255 | 256 | 254 | 254 |
| /25 | 255.255.255.128 | 0.0.0.127 | 128 | 126 | 126 |
| /26 | 255.255.255.192 | 0.0.0.63 | 64 | 62 | 62 |
| /27 | 255.255.255.224 | 0.0.0.31 | 32 | 30 | 30 |
| /28 | 255.255.255.240 | 0.0.0.15 | 16 | 14 | 14 |
| /29 | 255.255.255.248 | 0.0.0.7 | 8 | 6 | 6 |
| /30 | 255.255.255.252 | 0.0.0.3 | 4 | 2 | 2 |
| /31 | 255.255.255.254 | 0.0.0.1 | 2 | 2 | 0 |
| /32 | 255.255.255.255 | 0.0.0.0 | 1 | 1 | −1 |
把这张表当成一组关系来读，而不是一串答案。每往下一行网段就减半：/24 装 256 个地址，/25 装 128 个，/26 装 64 个。反掩码那一列就是子网掩码逐位取反，所以 255.255.255.192 和 0.0.0.63 永远出现在同一行。加粗的那两行是标准公式不再描述现实的地方，下面单开一节讲。
掩码列里只有最后一个八位组的取值需要背，因为它们是重复出现的：128、192、224、240、248、252、254、255。一个合法掩码的最后一个八位组，除了 0 就只能是这八个值之一。想自己换算一遍看看为什么，进制转换器可以把其中任意一个打成二进制。
反着读这张表：从子网掩码推回 CIDR
给定一个点分十进制掩码，数它有多少个 1 位。每个 255 贡献 8 位，剩下那个有意思的八位组贡献余下的部分：
| 掩码八位组取值 | 128 | 192 | 224 | 240 | 248 | 252 | 254 | 255 |
|---|---|---|---|---|---|---|---|---|
| 它增加的位数 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
所以 255.255.255.192 就是 8 + 8 + 8 + 2 = /26。而 255.255.252.0 是 8 + 8 + 6 + 0 = /22，因为 252 的二进制是 11111100。
顺带能看出两件事。既不是 255 也不是 0 的那个八位组就是边界八位组，一个合法掩码里最多只有一个。这个八位组的取值还直接给出块大小。
手算子网掩码与网络地址
这套机械方法只有三步，对任何前缀都适用。下面的例子用 192.168.1.130/26，但重点是流程，不是这个地址。
第 1 步：求出块大小
块大小是 256 − 边界掩码八位组。
/26 的掩码是 255.255.255.192，所以块大小是 256 − 192 = 64。这个尺寸的子网只能落在第四个八位组里 64 的倍数上：0、64、128、192。除此之外没有别的起点。
块大小和地址数量是同一个数，只是从掩码这一侧算出来的，而不是从位数那一侧。
第 2 步：判断地址落在哪个块里
用地址的边界八位组除以块大小，向下取整。
地址是 192.168.1.130，块大小是 64，于是 130 ÷ 64 = 2.03…，向下取整得 2。乘回去：2 × 64 = 128。这个地址落在从 128 开始的那个块里。
绝大多数错误都出在这一步，而且方向永远一样：把拿到手的地址默认当成它所在块的起点，而它通常不是。192.168.1.130 是一个主机地址，住在那个 /24 的第三个 /26 里。
第 3 步：网络地址、广播地址、首尾主机
块的起点就是网络地址。广播地址是块起点加上块大小再减 1。严格夹在两者之间的地址都可以分配：
Network 192.168.1.128
Broadcast 192.168.1.191
Usable 192.168.1.129 - 192.168.1.190
Usable 62 (of 64 total)
Netmask 255.255.255.192
Wildcard 0.0.0.63广播地址是 128 + 64 − 1 = 191。首个主机地址是网络地址加 1，最后一个主机地址是广播地址减 1，可用数量是 64 − 2 = 62，与速查表 /26 那一行吻合。
压缩成一句能对自己默念的话：块大小是 256 减掉掩码八位组；把地址向下取整到它的倍数，那就是网络地址；下一个块的起点减 1 就是广播地址。
这套方法并不专属于第四个八位组。/22 的掩码是 255.255.252.0，边界八位组是第三个，那里的块大小是 256 − 252 = 4。于是块从 10.0.0.0、10.0.4.0、10.0.8.0 开始，而 10.0.0.0/22 一直延伸到广播地址 10.0.3.255，可用地址是 10.0.0.1 到 10.0.3.254——一个广播域里装下四个连续的 /24。同样三步，换个八位组而已。
如果卡住你的是二进制与十进制之间的换算，进制转换完全指南把换算本身讲得比一篇子网划分文章该讲的深得多。
如果你想在脚本里核对而不是在脑子里核对，Python 标准库早就把这些都算好了：
import ipaddress
net = ipaddress.ip_network("192.168.1.130/26", strict=False)
print(net) # 192.168.1.128/26
print(net.network_address) # 192.168.1.128
print(net.broadcast_address) # 192.168.1.191
print(net.netmask) # 255.255.255.192
print(net.hostmask) # 0.0.0.63
print(net.num_addresses) # 64
print(len(list(net.hosts()))) # 62strict=False 的作用是允许你传一个主机地址而不是网络地址；用默认的 strict=True，同样的调用会抛出 ValueError。
「减 2」规则在哪里不再成立
这个减法背后是有道理的。在普通子网里，主机位全 0 的地址代表网络本身，全 1 的地址是定向广播地址。两者都不能配到接口上，所以一个有 2ⁿ 个地址的网段只能给主机 2ⁿ − 2 个。这就是 /24 给 254 个、/26 给 62 个的由来。
这个道理同时也是它的边界。当一个网段小到装不下这两个保留地址时，再去减它们就没有意义了。
/31 有两个地址，两个都是可用主机地址。 RFC 3021 为点对点链路定义了 /31。这种链路正好只有两个端点，没有共享网段，所以广播地址无事可做，网络地址也没什么可标识的。两个地址各归一端。在这里套 2ⁿ − 2 会得到 0，那是算术在回答一个它并不适用的拓扑问题。这个例外的适用条件是实打实的：/31 只在真正的点对点接口上才合法。多路访问的 LAN 网段仍然需要 /30 或更短的前缀，而 Windows 不接受网卡上配 /31。
/32 有一个地址，一个可用主机地址。 它是一条单主机路由，用在环回接口、静态路由、任播地址和单地址防火墙规则上。这里没有广播地址，所以公式里的 − 2 会返回 −1。
Python 这两处也是这么算的：
import ipaddress
p2p = ipaddress.ip_network("203.0.113.4/31")
print([str(h) for h in p2p.hosts()]) # ['203.0.113.4', '203.0.113.5']
host = ipaddress.ip_network("10.0.0.1/32")
print([str(h) for h in host.hosts()]) # ['10.0.0.1']与其背两个例外，不如记住这个减法减掉的是两个具体地址，减之前先确认它们真的存在。/31 和 /32 根本没有广播地址，所以什么都不用减。
地址总数、可用主机数、子网数量是三个不同的数
这三个数经常被混为一谈，而且情有可原，因为它们都是同一个前缀推出来的 2 的幂。
- 地址总数：/p 的地址总数是
2^(32 − p)。/26 是 64。 - 可用主机数：总数减 2，/31 和 /32 除外。/26 是 62。
- 子网数量：把父网段 /p 切成子网段 /q，得到
2^(q − p)个。把 /24 切成 /26 借了两位，所以是2² = 4个子网。
三者回答的是不同的问题，所以「一个 /26 给你 4」这句话，只有在问题是关于切分 /24 时才成立。切分本身也要花地址，因为每个子网都要保留自己的一对网络地址和广播地址。从一个 /24 里切出的四个 /26 一共有 4 × 62 = 248 个可用地址，父网段本来有 254 个，六个地址花在切分这件事上了。
反掩码与子网掩码：哪条命令要哪个
反掩码是子网掩码的按位取反。子网掩码里是 1 的位，反掩码里就是 0。拿速查表 /26 那一行来看：掩码 255.255.255.192，反掩码 0.0.0.63。把其中一个的每一位都翻过来就是另一个，所以它们总是成对出现。
这两个值的用法方向正好相反。子网掩码是拿去做按位与（AND）的，所以 1 位表示「这一位属于网络」。反掩码是一个匹配过滤器，所以 0 位表示「这一位必须匹配」，1 位表示「不关心」。底层是同一个操作，极性相反。如果位级机制还有点模糊，位运算完全指南以更通用的方式讲了 AND、OR 和 NOT。
设备要哪一个，不是偏好问题。以网段 192.168.1.128/26 为例：
! wants the subnet mask
ip address 192.168.1.129 255.255.255.192
! wants the wildcard mask
access-list 10 permit 192.168.1.128 0.0.0.63
network 192.168.1.128 0.0.0.63 area 0! Cisco ASA — wants the subnet mask, unlike IOS ACLs
access-list OUT permit ip 192.168.1.128 255.255.255.192 any# Linux iproute2 — takes the prefix directly
ip addr add 192.168.1.129/26 dev eth0Cisco IOS 的 ACL 和 OSPF 的 network 语句收反掩码，而 ASA 收子网掩码。同一个产品家族里，一家厂商用了两套约定，复制粘贴事故多半就出在这里。别的平台各有各的约定，所以在把一个值粘进不熟悉的字段之前，先确认那个字段要的是两者中的哪一个。
危险在于它的失效方式。把 255.255.255.192 粘进 IOS 的 ACL，路由器会把它当反掩码读：三个八位组全是 1，意思是「不关心」，于是前三个八位组根本不再参与匹配，这条规则的作用范围会远远超出你心里想的那个网段。没有语法错误，没有日志，只有一条范围完全不对的 permit 语句。反过来粘错至少还有被抓住的机会，因为 0.0.0.63 不是合法的子网掩码，它没有前导的一串 1。至于某个平台到底是拒绝它还是默默收下，这不该是在生产环境里发现的事。
为什么 ACL 反掩码可以有空洞，子网掩码不行
子网掩码必须是一串连续的 1 后面跟着 0。这不是约定，而是按位与操作能把地址干净地切成两部分的前提。255.0.255.0 这样的值中间有个洞，描述不出任何一条连贯的边界，设备会拒绝它。Python 也一样：
import ipaddress
ipaddress.ip_network("10.0.0.0/255.0.255.0")
# ValueError: '10.0.0.0/255.0.255.0' does not appear to be an IPv4 or IPv6 network合法的掩码只有 33 个，/0 到 /32。别的都是打错了。
ACL 反掩码没有这个约束，因为它并不是要把地址切成网络部分和主机部分。它是一个逐位的匹配过滤器，所以空洞是合法的，偶尔还挺有用——一个带空洞的反掩码可以匹配某个范围内所有奇数号地址。表达能力上的这点差异说明，两者压根不是同一类东西，只是在点分十进制里长得像，所以不能互换。
私有地址、CGNAT 与其他保留网段
前缀告诉你一个网段有多大。是哪一个网段，才决定它归不归你用。
| 网段 | 范围 | 保留依据 |
|---|---|---|
| 10.0.0.0/8 | 10.0.0.0 – 10.255.255.255 | RFC 1918 私有地址 |
| 172.16.0.0/12 | 172.16.0.0 – 172.31.255.255 | RFC 1918 私有地址 |
| 192.168.0.0/16 | 192.168.0.0 – 192.168.255.255 | RFC 1918 私有地址 |
| 100.64.0.0/10 | 100.64.0.0 – 100.127.255.255 | RFC 6598 运营商级 NAT |
| 169.254.0.0/16 | 169.254.0.0 – 169.254.255.255 | RFC 3927 链路本地 |
| 255.255.255.255/32 | 单个地址 | 受限广播 |
RFC 1918 那三段永远不会在公网上被路由，所以从里面分配地址是安全的。另外三段出现的理由各不相同。
100.64.0.0/10 是运营商级 NAT 空间。如果 ISP 给你的地址落在这一段，说明你在他们的 NAT 后面，不打隧道的话任何入站连接都到不了你。它不是 RFC 1918 意义上的私有地址，也不是你能拿来做内部规划的：运营商可能已经在路由器另一侧用着它了。
169.254.0.0/16 是链路本地地址。DHCP 失败时主机会给自己分一个，所以在接口上看见 169.254 开头的地址，那是一条诊断结论而不是一份配置：没有任何人回应 DHCP 请求。发往它的流量永远不会跨过路由器。
写文档和运维手册要举例子时，RFC 5737 专门保留了 192.0.2.0/24、198.51.100.0/24 和 203.0.113.0/24，就是为了让被复制粘贴的示例不会指向真实主机。
172.16.0.0/12 是十六个 /16，不是一个
这是最容易被搞错的保留网段，问题出在前缀上。/12 从第二个八位组借了四位，所以这个网段从 172.16.0.0 一直到 172.31.255.255，是十六个连续的 /16，而不只是 172.16.x.x。
后果是双向的。172.20.5.1 这样的地址是私有地址，稳稳落在范围内，尽管它开头不是 172.16。而 172.15.x.x 和 172.32.x.x 是别人的公网地址，所以一条按 172.0.0.0/8 写的防火墙规则、或者一句「内网范围可信」的判断，等于悄悄信任了互联网的一大片。
要确认这类边界，速查表给了你算法：/12 有 2^(32−12) 个地址，第二个八位组以 256 − 240 = 16 为步长推进，16 + 16 = 32，所以这个网段在 172.32.0.0 之前一步结束。
VLSM：把一个网段切成不等大的子网
等分子网很省事，通常也是错的。一个分支办公室拿到一个 192.168.1.0/24，可能需要四个大小完全不同的网段：一百台工作站、五十部话机、十几台服务器，外加少量管理接口。把这个 /24 等分成四个 /26，工作站网段在 62 台主机处就溢出了，而管理网段守着 62 个地址只服务十台设备。
可变长子网掩码（VLSM）的意思，是给每个网段它真正需要的前缀。下面把同一个 /24 切成一个 /25、一个 /26 和两个 /28。
从大到小分配。 每个块都必须落在自己尺寸的倍数上，所以最大的块先挑：
| 网段 | 所需主机数 | 前缀 | 网络地址 | 可用范围 | 广播地址 | 子网掩码 |
|---|---|---|---|---|---|---|
| 工作站 | 100 | /25 | 192.168.1.0 | 192.168.1.1 – 192.168.1.126 | 192.168.1.127 | 255.255.255.128 |
| 语音 | 50 | /26 | 192.168.1.128 | 192.168.1.129 – 192.168.1.190 | 192.168.1.191 | 255.255.255.192 |
| 服务器 | 12 | /28 | 192.168.1.192 | 192.168.1.193 – 192.168.1.206 | 192.168.1.207 | 255.255.255.240 |
| 管理 | 10 | /28 | 192.168.1.208 | 192.168.1.209 – 192.168.1.222 | 192.168.1.223 | 255.255.255.240 |
| 未分配 | — | /27 | 192.168.1.224 | 192.168.1.225 – 192.168.1.254 | 192.168.1.255 | 255.255.255.224 |
用三步法走一遍：
- /25 的块大小是
256 − 128 = 128，所以它从 0 开始，广播地址是0 + 128 − 1 = 127。可用 1 到 126，共 126 个地址，装 100 台工作站还有富余。速查表 /25 那一行是一致的：总数 128，可用 126。 - 下一个空闲地址是 128。/26 的块大小是 64，而 128 是 64 的倍数，正好放得下：网络地址 192.168.1.128，广播地址
128 + 64 − 1 = 191，可用 129 到 190。也就是 62 个可用地址给 50 部话机。速查表 /26 行：总数 64，可用 62。 - 下一个空闲是 192。/28 的块大小是 16，而
192 = 16 × 12，放得下：网络地址 192.168.1.192，广播地址 207，可用 193 到 206，14 个地址给 12 台服务器。速查表 /28 行：总数 16，可用 14。 - 再下一个空闲是 208，
208 = 16 × 13，所以第二个 /28 落在 192.168.1.208，广播地址 223，可用 209 到 222。
这样一共用掉 256 个地址里的 128 + 64 + 16 + 16 = 224 个，剩下 192.168.1.224 到 192.168.1.255。这 32 个地址恰好是一个对齐的 /27，以后的点对点链路就从这里出：里面能装十六个 /31，每条路由器链路一个。
不按大小排序要付什么代价？假设你把两个 /28 放在最前面：192.168.1.0/28 和 192.168.1.16/28。下一个空闲地址是 192.168.1.32，而 /25 必须从 128 的倍数开始，它没法从那里起步，只能往后跳到 192.168.1.128。32 到 127 之间的地址并没有丢，但它们只能当成更小的对齐块来用（192.168.1.32 处一个 /27、192.168.1.64 处一个 /26），于是剩余空间散落各处，而不是在末尾连成一整块。需求里再加一个网段，同样的腾挪就彻底放不下了。
按大小排序就能避开这一点。放下一个块之后，下一个空闲地址就是这个块尺寸的倍数；较大的那个 2 的幂的倍数，自动也是每个更小的 2 的幂的倍数，所以后面每一个更小的块，在前一个块结束的位置上天然就是对齐的。你永远不需要跳过一段。把这样一份规划写进交换机之前，扔进子网掩码计算器的划分表跑一遍，比手工核对每个网段的对齐要快。
五个能活到生产环境的错误
1. 把你输入的地址当成网络地址
症状： 一条防火墙规则什么都匹配不上，或者一条路由覆盖的是网段的另一半。
成因： 192.168.1.130/26 被读成了网络 192.168.1.0、广播 192.168.1.255，那是 /24 的边界，因为人在十进制里看到的就是它。
修法： 套第 2 步。块大小 64，130 ÷ 64 向下取整得 2，所以网络地址是 2 × 64 = 128。这个块是 192.168.1.128 到 192.168.1.191，而 192.168.1.0 完全是另一个子网。只要前缀比 /24 长，就先假定拿到的地址是主机地址，直到你亲手做过掩码运算为止。
2. 对 /31 套 2ⁿ − 2
症状： IPAM 工具或者一张表格报告某条点对点链路可用主机数为 0，而这条链路明明是通的、正在跑流量。 成因： 「减 2」规则假定存在一个网络地址和一个广播地址可供扣除。/31 上这两个都不存在。 修法： 把 /31 和 /32 当成公式的边界条件，而不是当成异常。RFC 3021 让 /31 的两个地址都可分配，而 /32 是一条只有一个地址的单主机路由。任何报出 0 或 −1 的东西，都是把公式用到了定义域之外。先确认具体接口是否支持 /31，因为这个例外只在真正的点对点链路上成立。
3. 把 172.16.0.0/12 只当成 172.16.x.x
症状： 某个内部服务在某个办公室访问不了，或者一条「屏蔽所有私有网段」的规则漏了。 成因： 那个 /12 被当成 /16 来读了。 修法： 这个范围是 172.16.0.0 到 172.31.255.255。ACL 和白名单要按前缀 172.16.0.0/12 来写，而不是按八位组的样子来写，并且记住 172.15.x.x 和 172.32.x.x 在它之外、在公网上。如果要手工判断，边界八位组是第二个，步长是 16。
4. 把反掩码粘进要子网掩码的字段
症状： 一条 ACL 放行的范围远超或者远小于预期，而配置里看不出哪里不对。 成因： IOS 的 ACL 和 OSPF 的 network 语句收反掩码，ASA 收子网掩码，而 0.0.0.63 和 255.255.255.192 扫一眼看着差不多。 修法： 粘之前检查字段，而不是粘完再说。一个好用的判据：只要前缀是 /8 或更长，子网掩码一定以 255 开头，反掩码一定以 0 开头。如果 ACL 或 OSPF 的 network 语句里躺着一个以 255 开头的值，那就是子网掩码跑进了反掩码的位置。
5. 写出不连续的掩码，或者无意中生成一个
症状： 设备拒绝某一行配置，或者自研脚本产出的掩码看着挺像样，其实是错的。 成因： 255.0.255.0 这样的值不是合法子网掩码，它中间有个洞。脚本那一版更隐蔽：在 JavaScript 里，移位运算符会把右操作数对 32 取模，所以超出范围的前缀不会抛错，而是悄悄产出一个看着合理的错误掩码（33 变成 /1，−1 变成 /31）。 修法： 移位之前先校验前缀范围，并拒绝任何不是「一串 1 后面跟一串 0」的掩码。在这里，一个遇到坏输入就抛异常的库，比一个会猜的库值钱得多，因为这两种失效形式都是静默的。
FAQ
子网和 VLAN 有什么区别？
VLAN 是在交换机上配置的二层广播域，子网是三层的一段地址范围。两者通常一一对应，但没有任何机制强制这一点：你可以把两个子网放在一个 VLAN 上，也可以把一个 VLAN 跨站点做 trunk。给子网重新编号，VLAN ID 不会跟着变。
把一个 /24 切成 /26，能得到几个子网？
四个。数量是 2 的借位数次方，/26 比 /24 长两位，所以是 2² = 4 个子网，每个 64 个地址。每个子网都要保留自己的网络地址和广播地址，所以这四个 /26 一共 248 个可用地址，而父 /24 有 254 个。
CIDR 表示法在 IPv6 里也是同一套吗？
斜杠后面数的仍然是前导网络位，所以 /64 表示 128 位里有 64 位是网络位。不成立的是「减 2」规则：IPv6 没有广播地址，所以不用从总数里减掉任何东西。上面这张速查表和它背后的计算器都只针对 IPv4。
0.0.0.0/0 是什么意思？
网络位为零，所以它匹配每一个 IPv4 地址。在路由表里它是默认路由，没有更具体的前缀匹配时才走它。作为绑定地址时它表示「所有接口」，所以监听在 0.0.0.0 上的服务，从这台机器接入的每一个网络都能访问到。
同一个网络里两个子网重叠会怎样？
路由器会挑更具体的那条路由，因为转发永远优先最长匹配前缀；重叠区域内的主机，则对哪些目的地属于本地这件事看法不一。症状是局部的：有些目的地通、有些不通，而且从哪里测试会改变通的是哪一批。
A、B、C 类地址为什么被 CIDR 取代了？
因为分类地址只提供三种尺寸：/8、/16 和 /24。一个需要 300 个地址的机构，要么拿一个 B 类然后浪费掉绝大部分，要么跑两条 C 类路由。CIDR 让前缀可以是任意长度，既减缓了地址耗尽，也让运营商能把许多客户网段汇聚成一条路由。
192.168.0.0/16 这样的私有网段，我可以随便切吗？
可以。RFC 1918 空间归你，按任何前缀长度划分都行，网络外面的人也看不见。约束来自内部：和合作方网络、或者以后要对等互联的云 VPC 撞了段，拆起来代价很高，所以规划时往往会避开每台家用路由器都在用的那几个网段。
记住这几条就够用了。前缀数的是网络位，块大小是 256 − 边界掩码八位组。把地址向下取整到块大小的倍数得到网络地址，再加块大小减 1 得到广播地址。为那对保留地址减 2，但前提是 /31 或 /32 没有先把减的理由拿走。靠形状区分反掩码和子网掩码。先分配大块，再分配小块。
这些一旦进了你手里，日常大多数场合就不用开工具了。要在配置进路由器之前核对一份规划，或者一眼看清某个网段的二进制边界，子网掩码计算器会在你的浏览器本地把算术做完。