How To Calculate Subnet Masks For Class C Networks

Subnetting a Class C network usually comes down to one question: how many subnets or hosts do you need, and what mask gives you that result without wasting addresses? If you can read a Subnet Mask, understand IP Addressing, and do a few Subnet Calculation steps by hand, you can plan smaller, cleaner IPv4 networks with confidence.

Default Class C Mask	255.255.255.0 as of June 2026
CIDR Equivalent	/24 as of June 2026
Usable Hosts	254 per subnet as of June 2026
Typical Class C Range	192.0.0.0 to 223.255.255.255 as of June 2026
Common Borrowed Masks	/25, /26, /27, /28 as of June 2026
Block Size Method	256 minus the subnetted octet as of June 2026
Primary Use Case	Small to medium LAN segmentation as of June 2026

Understanding Class C Networks And IP Basics

A Class C address is an IPv4 address in the traditional classful range from 192.0.0.0 to 223.255.255.255, although modern networks use CIDR instead of relying on classful rules alone. In a default Class C network, the first three octets identify the Network, and the last octet is available for Host addresses.

This is why Class C networks are common in small and medium-sized environments. A single /24 can support 254 usable hosts, which is enough for many office floors, lab networks, branch sites, printers, and user VLANs.

The key terms are simple:

• Network address identifies the subnet itself.
• Broadcast address reaches every host in that subnet.
• Usable host addresses sit between those two values.

Binary is the foundation of subnetting because the subnet mask works at the bit level, not the decimal level. Each bit in the mask tells the device whether the corresponding bit in the IP address belongs to the network portion or the host portion.

Subnetting is not about memorizing decimal patterns. It is about understanding where the bits move when you borrow host space for more subnets.

That’s also why IP Addressing and subnetting show up together in troubleshooting. The CompTIA N10-009 Network+ Training Course emphasizes IPv6, DHCP, and switch failures, and subnet math still matters because many real networks remain dual-stack or IPv4-heavy. You cannot troubleshoot address scope problems if you cannot tell whether an address belongs in the right subnet.

For reference, IPv4 uses 32 bits, and a Class C /24 mask uses 24 bits for the network and 8 bits for the host. Once you understand that split, every subnet calculation becomes a controlled tradeoff between more subnets and fewer hosts per subnet.

Official background on IPv4 and addressing concepts is available from IETF RFC 791, which defines Internet Protocol version 4.

What Is The Default Class C Subnet Mask?

The default Class C subnet mask is 255.255.255.0, which is the decimal form of a /24 prefix. It tells devices that the first 24 bits are the network portion and the last 8 bits are the host portion.

In binary, that mask looks like this:

• 255 = 11111111
• 255 = 11111111
• 255 = 11111111
• 0 = 00000000

That pattern explains why a default Class C network has 254 usable hosts. Eight host bits gives you 2⁸ = 256 total addresses, and you subtract 2 for the network address and broadcast address. The result is 254 usable addresses for devices.

When you look at an address like 192.168.10.0/24, the last octet is the host space. The network address is 192.168.10.0, the broadcast address is 192.168.10.255, and usable hosts run from 192.168.10.1 to 192.168.10.254.

This is the core move in Class C subnetting. You start with a /24 and then decide whether you need smaller chunks such as /25, /26, or /27. Cisco’s official subnetting guidance and address planning references align with this bit-based approach, and Cisco’s documentation is a solid cross-check when you are verifying mask behavior in routed or switched environments. See Cisco for vendor documentation on IPv4 addressing and routing concepts.

Subnetting Fundamentals You Need Before Calculating

Borrowed bits are the host bits you reassign to the network portion to create additional subnets. If you borrow 1 bit from a Class C /24, you create 2 subnets. If you borrow 2 bits, you create 4 subnets. If you borrow 3 bits, you create 8 subnets.

Host bits are the bits left over for devices inside each subnet. More host bits mean more usable addresses per subnet, but fewer subnets overall. That tradeoff is the entire point of subnet planning.

The basic formulas are straightforward:

1. Total subnets = 2^{borrowed bits}
2. Total addresses per subnet = 2^{host bits}
3. Usable hosts per subnet = 2^{host bits} – 2

The subtraction of 2 matters because every subnet reserves two addresses. The first address is the Network Address, and the last address is the broadcast address. People forget this constantly, especially when they are doing quick mental checks during network planning or a troubleshooting call.

Here is the most common mistake: someone sees 64 addresses in a /26 and assumes all 64 are usable. They are not. A /26 gives you 62 usable hosts because 2 addresses are reserved.

Another mistake is mixing decimal reasoning with binary reality. A mask like 255.255.255.192 is not “just 192.” It means the last octet has two borrowed bits, which changes the subnet size, host count, and block size all at once.

For a standards-based perspective on network design and segmentation, NIST’s guidance on network architecture and the NIST SP 800-41 Rev. 1 firewall guidance remains useful for understanding why subnet boundaries matter in security design.

How Do You Calculate A Subnet Mask Step By Step?

You calculate a subnet mask by starting with the number of required subnets or hosts, then borrowing enough bits from the host portion to satisfy that requirement. Once you know how many bits you need, the rest is conversion and verification.

1. Identify the need. Decide whether you are optimizing for subnets or for hosts. If a department needs 50 devices, you plan for hosts; if a campus needs isolated segments, you plan for subnets.

   For example, if you need at least 6 subnets from a Class C /24, you need 3 borrowed bits because 2³ = 8 subnets.

2. Borrow bits from the last octet. Each borrowed bit reduces the host space. Borrowing 1 bit changes the mask to /25, borrowing 2 bits changes it to /26, and borrowing 3 bits changes it to /27.

   A /25 mask is 255.255.255.128, a /26 is 255.255.255.192, and a /27 is 255.255.255.224.

3. Convert bit counts to decimal mask values. In the last octet, the mask values rise in powers of two: 128, 192, 224, 240, 248, 252, 254, 255. Those numbers reflect how many leading 1s are set in the octet.

   This is where a subnet calculator can help, but you should still know the pattern by hand. Manual calculation is faster during exams and much safer during troubleshooting.

4. Translate the mask into CIDR notation. The prefix length is the number of 1 bits in the mask. 255.255.255.128 equals /25, 255.255.255.192 equals /26, and 255.255.255.224 equals /27.

   CIDR notation is what you will see in routing tables, ACLs, cloud networking screens, and documentation. It is not optional knowledge.

5. Check the usable hosts and block size. If a /26 leaves 6 host bits, the total is 64 addresses and 62 usable hosts. The block size is 256 minus 192, which equals 64.

   That means the subnets increment by 64 in the last octet: 0, 64, 128, and 192.

A quick example helps. Starting with 255.255.255.0, if you need four subnets, borrow 2 bits from the host octet. The new mask becomes 255.255.255.192, or /26. Each subnet has 64 addresses and 62 usable hosts.

Microsoft’s networking documentation on Microsoft Learn is a practical reference when you are checking how IPv4 addresses are assigned in Windows environments, especially in DHCP scopes and interface configuration.

What Are The Common Class C Subnet Masks And CIDR Equivalents?

The most useful Class C subnet masks are the ones you actually deploy: /25, /26, /27, /28, and sometimes /29 or /30 for special cases. These masks trade host capacity for finer segmentation.

255.255.255.128	/25 — 2 subnets, 126 usable hosts each
255.255.255.192	/26 — 4 subnets, 62 usable hosts each
255.255.255.224	/27 — 8 subnets, 30 usable hosts each
255.255.255.240	/28 — 16 subnets, 14 usable hosts each
255.255.255.248	/29 — 32 subnets, 6 usable hosts each
255.255.255.252	/30 — 64 subnets, 2 usable hosts each

Use /25 when you want two large segments. Use /26 when you want a balance between host count and segmentation. Use /27 or /28 when you want tighter control for smaller departmental networks, lab segments, or infrastructure VLANs.

The block size is always the same idea: subtract the interesting octet from 256. For /25, the block size is 128. For /26, it is 64. For /27, it is 32. That block size tells you where each subnet starts and ends.

Here is the practical interpretation:

• /25 is useful when one /24 needs to be split into two big groups.
• /26 works well for four departments or four floor segments.
• /27 is common for smaller user pools, printers, or lab networks.
• /30 is often used for point-to-point links where only two hosts are needed.

For official protocol context, IETF CIDR and IPv4 addressing standards remain the source of truth. For operational guidance, the Cloudflare learning center offers a clean explanation of subnet behavior, but network administrators should still rely on RFCs and vendor documentation for implementation details.

How Do You Calculate Subnet Ranges And Block Sizes?

Block size is the increment between subnet network addresses in the subnetted octet. In a Class C network, you usually calculate it by subtracting the mask value in the last octet from 256.

That means:

• /25 uses 128, so the block size is 256 – 128 = 128.
• /26 uses 192, so the block size is 256 – 192 = 64.
• /27 uses 224, so the block size is 256 – 224 = 32.
• /28 uses 240, so the block size is 256 – 240 = 16.

Once you know the block size, subnet ranges are easy to list. For example, in 192.168.1.0/26, the subnets begin at 0, 64, 128, and 192. The broadcast address is always the last address before the next subnet begins.

Here is a worked example using /26:

1. Subnet 1: Network 192.168.1.0, usable hosts 192.168.1.1 to 192.168.1.62, broadcast 192.168.1.63.
2. Subnet 2: Network 192.168.1.64, usable hosts 192.168.1.65 to 192.168.1.126, broadcast 192.168.1.127.
3. Subnet 3: Network 192.168.1.128, usable hosts 192.168.1.129 to 192.168.1.190, broadcast 192.168.1.191.
4. Subnet 4: Network 192.168.1.192, usable hosts 192.168.1.193 to 192.168.1.254, broadcast 192.168.1.255.

If you need to verify whether an IP belongs to a subnet, check whether the host address falls between the network and broadcast values. That is the fastest rule for both manual calculation and live troubleshooting.

For security-minded planning, subnet ranges also matter to ACL design and east-west segmentation. MITRE’s reference on MITRE ATT&CK helps security teams understand why network separation affects detection and containment, even when the subnet math itself is simple.

Can You Walk Through Practical Class C Subnet Calculation Examples?

Yes. The easiest way to learn subnetting is to work the same network several times with different masks until the pattern becomes automatic. Use 192.168.1.0/24 as the base example because the octets are easy to read and the block boundaries are obvious.

Split 192.168.1.0/24 Into Two Subnets With /25

A /25 borrows 1 bit, which creates 2 subnets and leaves 7 host bits. That gives 128 addresses per subnet and 126 usable hosts.

• Subnet 1: 192.168.1.0/25
• First usable: 192.168.1.1
• Last usable: 192.168.1.126
• Broadcast: 192.168.1.127

• Subnet 2: 192.168.1.128/25
• First usable: 192.168.1.129
• Last usable: 192.168.1.254
• Broadcast: 192.168.1.255

Split The Same Network Into Four Subnets With /26

A /26 borrows 2 bits, which creates 4 subnets and leaves 6 host bits. That gives 64 addresses per subnet and 62 usable hosts.

• Subnet 1: 192.168.1.0/26, hosts 1 to 62, broadcast 63.
• Subnet 2: 192.168.1.64/26, hosts 65 to 126, broadcast 127.
• Subnet 3: 192.168.1.128/26, hosts 129 to 190, broadcast 191.
• Subnet 4: 192.168.1.192/26, hosts 193 to 254, broadcast 255.

Split The Same Network Into Eight Subnets With /27

A /27 borrows 3 bits, which creates 8 subnets and leaves 5 host bits. That gives 32 addresses per subnet and 30 usable hosts.

This is the tradeoff you need to recognize in real planning. You gain more segments, but each segment shrinks quickly. If a department may grow beyond 30 devices, a /27 may be too tight unless you have another plan ready.

• Subnet 1: 192.168.1.0/27, hosts 1 to 30, broadcast 31.
• Subnet 2: 192.168.1.32/27, hosts 33 to 62, broadcast 63.
• Subnet 3: 192.168.1.64/27, hosts 65 to 94, broadcast 95.
• Subnet 4: 192.168.1.96/27, hosts 97 to 126, broadcast 127.
• Subnet 5: 192.168.1.128/27, hosts 129 to 158, broadcast 159.
• Subnet 6: 192.168.1.160/27, hosts 161 to 190, broadcast 191.
• Subnet 7: 192.168.1.192/27, hosts 193 to 222, broadcast 223.
• Subnet 8: 192.168.1.224/27, hosts 225 to 254, broadcast 255.

The same method works for any Class C address, private or public. The network number changes, but the math stays the same because the mask controls the subnet boundaries, not the address flavor.

For route planning, firewalls, and cloud-style segmentation, this is the exact kind of calculation you will repeat. The Cloudflare CIDR guide is useful for visual reinforcement, while the authoritative standard remains the CIDR framework documented through IETF.

What Mistakes Should You Avoid When Subnetting Class C Networks?

Most subnetting mistakes are not math failures. They are assumption failures. A technician sees an address, guesses the mask, and never checks whether the subnet actually fits the host count.

The most common errors are predictable:

• Confusing the default mask with the custom mask and planning the network as if it is still a /24.
• Forgetting reserved addresses and counting the network and broadcast addresses as usable hosts.
• Using decimal-only reasoning and ignoring how bit borrowing changes the mask.
• Mixing up block size and host range when mapping subnet boundaries.
• Applying classful thinking too rigidly in a CIDR-based design environment.

Here is a practical example of a bad assumption. Someone wants 50 hosts and chooses a /27 because it “sounds close.” That subnet only provides 30 usable hosts, so the design fails immediately. A /26 is the correct choice because it provides 62 usable hosts.

Another recurring issue is forgetting that subnetting rules are easier when the subnetted octet is obvious. In Class C, the action usually happens in the fourth octet. In Class B or when masks cross octet boundaries, the calculations become more complex, and the same shortcut logic can lead to mistakes.

The fastest way to get subnetting wrong is to trust your intuition before you verify the host count.

Good network planning means checking the math twice before deployment. That matters in DHCP scope design, switch VLAN assignment, and firewall rule placement because a wrong mask can produce duplicate addressing, unreachable hosts, or misrouted traffic.

For workforce and job-role context, the U.S. Bureau of Labor Statistics Occupational Outlook Handbook shows continued demand for network-related roles, which is one reason subnetting remains a baseline skill rather than a niche topic. Official NIST guidance also reinforces why address planning matters for segmented systems and security zoning.

What Tools And Quick Checks Help You Calculate Subnet Masks Faster?

Subnet calculators are useful for verification, but they should confirm your work, not replace it. If you rely on a calculator before you can estimate host counts and block size on your own, you will struggle when the tool is unavailable or when you need a quick answer in a troubleshooting session.

A simple cheat sheet still works well. Keep the common masks and block sizes in front of you:

• /25 = 128 block size, 126 usable hosts
• /26 = 64 block size, 62 usable hosts
• /27 = 32 block size, 30 usable hosts
• /28 = 16 block size, 14 usable hosts
• /29 = 8 block size, 6 usable hosts
• /30 = 4 block size, 2 usable hosts

Spreadsheets are also practical for repetitive subnet planning. A simple sheet with columns for network address, prefix length, block size, first host, last host, and broadcast address can speed up branch planning or lab design. The point is not automation for its own sake. The point is reducing human error.

Command-line tools help too. On Windows, ipconfig shows the configured mask, and ping or tracert can help test reachability when a subnet is wrong. On Linux, ip addr, ip route, and ping are the quick checks that matter most.

For official operating system guidance, Microsoft’s documentation on network settings in Windows Server networking is a useful check when you are validating static configuration, DHCP behavior, or adapter properties in production.

How Do You Verify It Worked?

You verify subnetting by confirming the address falls inside the expected network, the host count matches the design, and the system can communicate with the right peers. If any one of those checks fails, the subnet mask, gateway, or DHCP scope may be wrong.

Start with the address itself. If you planned 192.168.1.64/26, then any address from 192.168.1.65 to 192.168.1.126 should be usable. If you see a host assigned 192.168.1.130 with that mask, it is not in the correct subnet.

Then verify the machine configuration:

• Windows: run ipconfig /all and check the IPv4 address, subnet mask, and default gateway.
• Linux: run ip addr and ip route to confirm the prefix and route.
• Network devices: review interface status and routing tables for the expected mask.

Success looks like this: hosts communicate with devices in the same subnet, the default gateway is reachable, and traffic to other subnets is routed correctly. Failure usually looks like APIPA addresses, duplicate gateway complaints, or hosts that can ping themselves but nothing beyond the local segment.

Common symptoms of a bad subnet calculation include:

• Devices receiving addresses outside the intended range.
• Broadcast-heavy behavior because the subnet is too broad.
• Hosts failing to reach the gateway because the mask is too narrow or too wide.
• DHCP scope exhaustion because the subnet contains fewer usable hosts than expected.

For network verification and security validation, CIS benchmarks and vendor routing documentation are useful references, but the actual proof is in the address math and live connectivity. You can also check segmentation logic against NIST and switch behavior when validating VLAN-to-subnet mapping in a lab or production network.

Conclusion

Calculating subnet masks for Class C networks is a repeatable process once you understand the bit math behind it. Start with the default 255.255.255.0, decide how many subnets or hosts you need, borrow the right number of bits, and then map the resulting ranges with block size.

The essentials are always the same: know your Subnet Mask, know your CIDR prefix, know your usable host count, and know where the network and broadcast boundaries sit. If you can do those four things, you can handle most Class C Subnet Calculation tasks without a calculator.

Practice with /25, /26, and /27 until the ranges feel automatic. That skill pays off in DHCP planning, VLAN design, switch troubleshooting, and address documentation, which is exactly why it belongs in everyday network administration work and in the CompTIA N10-009 Network+ Training Course.

Before you deploy anything, verify the subnet on paper or in a spreadsheet, then test it on the wire. One clean validation step now is cheaper than a late-night outage caused by a bad mask.

CompTIA® and Network+™ are trademarks of CompTIA, Inc.