Loading content...
Class C addresses represent the smallest allocatable unit in the classful addressing hierarchy, designed for the numerous small organizations that would never need thousands of IP addresses. With only 254 usable hosts per network, Class C was intended for small businesses, branch offices, and individual departments.
Yet this apparent precision created its own problems. Organizations needing 300 addresses faced an impossible choice: accept a single, inadequate Class C (254 hosts), or manage the routing complexity of multiple discontiguous blocks. This 'too small, too many' paradox made Class C both the most numerous allocation category and the most administratively burdensome.
The first-octet range of 192 to 223 encompasses over 2 million potential Class C networks—a vast pool that proved essential for the Internet's democratic expansion, even as its limitations drove the CIDR revolution.
By completing this page, you will understand: (1) The binary structure defining Class C (leading bits '110'), (2) The 24/8 network/host split and its implications, (3) Why 254 hosts proved both too small and essential, (4) The challenge of managing multiple Class C blocks, (5) The private 192.168.x.x range ubiquitous in homes and small offices, and (6) How Class C problems catalyzed CIDR and provider-based addressing.
Class C addresses are identified by their leading three bits being '110'. This three-bit prefix creates the precise mathematical boundaries that define Class C behavior:
Binary anatomy of a Class C address:
┌───────────────────────────────────────────────────────────────────────┐│ 32-bit IPv4 Address │├───────────────────────────────────────────────────────────────────────┤│ 1 │ 1 │ 0 │ N │ N │ N │ N │ N │ N │ N │ N │ N │ N │ N │ N │...│ N │ N │ N │ N │ N │ N │ H │ H │ H │ H │ H │ H │ H │ H │├───┴───┴───┼───────────────────────────────────────────────────────────┤│ Class │ Network ID (24 bits) │ Host ID (8 bits) ││ bits │ Octets 1, 2, and 3 │ Octet 4 only │└───────────┴─────────────────────────────┴─────────────────────────────┘ Binary Breakdown:┌───────────┬───────────┬───────────┬───────────┐│ Octet 1 │ Octet 2 │ Octet 3 │ Octet 4 ││ 110NNNNN │ NNNNNNNN │ NNNNNNNN │ HHHHHHHH ││ Network Portion │ Host │└───────────────────────────────────┴───────────┘ First three bits = 110 (mandatory for Class C)Remaining 21 network bits: 2^21 = 2,097,152 possible Class C networks8 host bits: 2^8 - 2 = 254 usable hosts per networkMathematical derivation of the range:
11000000 = 19211011111 = 223Therefore, any address with first octet between 192 and 223 is definitively Class C. The second and third octets provide 16 additional bits to distinguish among the 2 million+ networks in this class.
The default subnet mask: Class C addresses carry an implicit mask of 255.255.255.0 (or /24 in CIDR notation). This is the most common subnet mask in networking—so common that /24 has become nearly synonymous with 'a network' in casual discussion.
To identify Class C: Check if 192 ≤ first octet ≤ 223. In binary, this means the first three bits are '110'. Example: 203.0.113.25 → 203 = 11001011 → Starts with '110' → Class C. The 192.168.x.x private range you use at home is entirely Class C.
Class C's address space spans from 192.0.0.0 to 223.255.255.255. Despite having the smallest per-network capacity, Class C represents half of the routable IPv4 address space by sheer network count:
| Property | Value | Derivation |
|---|---|---|
| First octet range | 192 – 223 | Binary 11000000 to 11011111 |
| Total networks | 2,097,152 | 2^21 (21 variable bits in network portion) |
| Total addresses per network | 256 | 2^8 (8 host bits) |
| Usable hosts per network | 254 | 2^8 - 2 (exclude network and broadcast) |
| Total Class C addresses | 536,870,912 | 2,097,152 × 256 = 2^29 addresses |
| Percentage of IPv4 space | 12.5% | (2^29) / (2^32) = 1/8 |
Network identification example:
Example Address: 203.0.113.47 Step 1: Identify the class First octet = 203 Binary: 11001011 First three bits = '110' → Class C Step 2: Apply Class C mask (255.255.255.0) Address: 203.0.113.47 Mask: 255.255.255.0 Step 3: Extract network ID Network ID = 203.0.113.0 (first 24 bits) Step 4: Extract host ID Host ID = 0.0.0.47 (last 8 bits) Result:┌───────────────────────┬─────────────────┐│ Network: 203.0.113 │ Host: .47 ││ (3 octets) │ (1 octet) │└───────────────────────┴─────────────────┘ Reserved addresses in network 203.0.113.0/24: - Network address: 203.0.113.0 - Broadcast address: 203.0.113.255 - Usable range: 203.0.113.1 – 203.0.113.254The example 203.0.113.0/24 is from the TEST-NET-3 range (RFC 5737), specifically reserved for documentation. Other documentation ranges: 192.0.2.0/24 (TEST-NET-1) and 198.51.100.0/24 (TEST-NET-2). Use these in examples to avoid accidentally referencing real networks.
Class C's defining characteristic—only 254 usable addresses—created a dual-edged reality. For truly small organizations, it was perfectly sized. For medium organizations, it was maddeningly insufficient.
The allocation efficiency paradox:
| Scenario | Need | Class C Provides | Result |
|---|---|---|---|
| Small office (20 devices) | ~30 IPs | 254 usable | 86% waste, but manageable |
| Medium office (300 devices) | ~400 IPs | 254 per block | Need 2 blocks, routing complexity |
| Growing startup (1,000 devices) | ~1,200 IPs | 254 per block | Need 5 blocks, serious management burden |
| Branch campus (5,000 devices) | ~6,000 IPs | 254 per block | Need 24 blocks, administrative nightmare |
The multiple-block management nightmare:
Organizations requiring more than 254 addresses had to request multiple Class C blocks. Unlike a single Class B (which provided contiguous 65K addresses), multiple Class Cs often arrived from different parts of the address space:
This created severe operational challenges:
Organizations stuck between Class C (too small) and Class B (unavailable or wasteful) paid a 'small site tax' in operational complexity. This inefficiency drove demand for CIDR's fine-grained allocations: /22 (1,022 hosts), /20 (4,094 hosts), etc.
RFC 1918 designated 192.168.0.0/16 for private networking—the range that became synonymous with home and small office networks worldwide. Despite being called 'Class C private space,' it actually spans 256 contiguous Class C networks.
Why 192.168.x.x became universal:
RFC 1918 Class C Private Range: 192.168.0.0/16 Block boundaries (256 Class C networks):├── 192.168.0.0/24 (192.168.0.0 – 192.168.0.255) ← Common router default├── 192.168.1.0/24 (192.168.1.0 – 192.168.1.255) ← Most common home network├── 192.168.2.0/24 (192.168.2.0 – 192.168.2.255)│ ... (192.168.3 through 192.168.254) ...└── 192.168.255.0/24 (192.168.255.0 – 192.168.255.255) Total addresses: 256 × 256 = 65,536 addressesUsable hosts: 256 × 254 = 65,024 (excluding network/broadcast per /24) Practical allocation: 192.168.1.0/24 → Home main network 192.168.2.0/24 → Home IoT/guest network 192.168.10.0/24 → Small office main 192.168.50.0/24 → Small office guest WiFiThe ubiquity problem:
While 192.168.x.x's universality is convenient, it creates challenges:
Enterprise networks often avoid 192.168.x.x entirely to prevent conflicts when employees work remotely.
For organizations, use 10.x.x.x internally to avoid home network conflicts. Reserve 192.168.x.x for guest WiFi or isolated test environments. When VPN-connected employees work from home, 10.x.x.x corporate addresses won't conflict with their 192.168.x.x home networks.
If Class B caused routing table concerns, Class C created a genuine crisis. With over 2 million possible networks, each requiring a separate routing entry, backbone routers faced memory exhaustion as Class C allocations proliferated.
| Class | Networks Possible | Memory per Entry (est.) | Total Potential Memory |
|---|---|---|---|
| Class A | 128 | ~100 bytes | ~12.8 KB |
| Class B | 16,384 | ~100 bytes | ~1.6 MB |
| Class C | 2,097,152 | ~100 bytes | ~200 MB |
The problem scale:
In the early 1990s, backbone routers had 4-16 MB of memory. If even 10% of Class C networks were allocated and announced, routers would exhaust memory purely on routing tables. This wasn't theoretical—routers were failing as Class C allocations accelerated.
The CIDR rescue:
CIDR (RFC 1519, 1993) transformed Class C management through supernetting and provider-based allocation:
Supernetting: Instead of receiving scattered Class Cs, organizations received contiguous blocks from their upstream provider (e.g., 203.0.112.0/22 = four contiguous Class Cs)
Aggregation: Providers announced summary routes covering all customer allocations, dramatically reducing global routing table size
Hierarchical allocation: RIRs allocated large blocks to providers, who sub-allocated to customers, enabling aggregation at each tier
Before CIDR (Classful Routing):ISP must announce separate routes for each customer Class C: → 203.0.112.0/24 (Customer A) → 203.0.113.0/24 (Customer B) → 203.0.114.0/24 (Customer C) → 203.0.115.0/24 (Customer D) = 4 routing table entries globally After CIDR (Supernetting):ISP announces single aggregate: → 203.0.112.0/22 (covers all four customers) = 1 routing table entry globally Reduction: 75% fewer routes, scalable across millions of networksCIDR's aggregation benefit came with a cost: address portability. If Customer A in the example changes ISPs, they cannot take 203.0.112.0/24—it's part of the original ISP's aggregate. Changing providers means renumbering. This tradeoff remains contentious in IP address policy debates.
Several portions of Class C space are reserved for special purposes, reducing the publicly allocatable range. Understanding these reservations prevents configuration errors and clarifies documentation examples:
| Range | Purpose | RFC | Notes |
|---|---|---|---|
192.0.0.0/24 | IETF Protocol Assignments | RFC 6890 | Special addresses assigned by IANA |
192.0.2.0/24 | TEST-NET-1 (Documentation) | RFC 5737 | Use in examples and documentation |
192.88.99.0/24 | 6to4 Relay Anycast (Deprecated) | RFC 7526 | Historically for IPv6 transition |
192.168.0.0/16 | Private Use (RFC 1918) | RFC 1918 | Not routed on public Internet |
198.18.0.0/15 | Network Interconnect Testing | RFC 2544 | Benchmarking inter-network devices |
198.51.100.0/24 | TEST-NET-2 (Documentation) | RFC 5737 | Use in examples and documentation |
203.0.113.0/24 | TEST-NET-3 (Documentation) | RFC 5737 | Use in examples and documentation |
Using documentation ranges correctly:
When writing network documentation, training materials, or code examples, always use TEST-NET ranges rather than randomly chosen addresses. This prevents:
✓ CORRECT: Use documentation ranges Example server: 203.0.113.10 Example client: 198.51.100.25 Example network: 192.0.2.0/24 ✗ INCORRECT: Random addresses that might be real Example server: 8.8.8.8 (This is Google DNS!) Example client: 1.1.1.1 (This is Cloudflare!) Example network: 208.0.0.0/8 (This is allocated!) The TEST-NET ranges are guaranteed to never be routed publicly,making them safe for any documentation or testing purpose.Remember: 192.0.2.x (TEST-NET-1), 198.51.100.x (TEST-NET-2), 203.0.113.x (TEST-NET-3). Each provides a full /24 (254 hosts) for documentation examples. Use them consistently in all technical writing.
While Class C networks are small (254 hosts), they can still be subnetted for segmentation, security, or address conservation. Subnetting a /24 creates even smaller networks—a practice common in modern enterprise and cloud environments.
Common Class C subnet divisions:
| New Mask | CIDR | Subnets | Hosts per Subnet | Common Use |
|---|---|---|---|---|
| 255.255.255.128 | /25 | 2 | 126 | Split network in half |
| 255.255.255.192 | /26 | 4 | 62 | Department segments |
| 255.255.255.224 | /27 | 8 | 30 | Small team networks |
| 255.255.255.240 | /28 | 16 | 14 | Point-to-point links |
| 255.255.255.248 | /29 | 32 | 6 | Small server groups |
| 255.255.255.252 | /30 | 64 | 2 | Router-to-router links |
| 255.255.255.254 | /31 | 128 | 2* | Point-to-point (RFC 3021) |
| 255.255.255.255 | /32 | 256 | 1 | Host routes |
Original Network: 192.168.1.0/24 (254 usable hosts)New Mask: /26 = 255.255.255.192 Binary view of subnetting:192.168.1.0 = 11000000.10101000.00000001.00|000000 ^^ Borrowed 2 bits from host portion Creates 2^2 = 4 subnets Resulting subnets:┌────────────────────────────────────────────────────────────────┐│ Subnet 1: 192.168.1.0/26 ││ Network: 192.168.1.0 ││ Usable: 192.168.1.1 – 192.168.1.62 ││ Broadcast: 192.168.1.63 │├────────────────────────────────────────────────────────────────┤│ Subnet 2: 192.168.1.64/26 ││ Network: 192.168.1.64 ││ Usable: 192.168.1.65 – 192.168.1.126 ││ Broadcast: 192.168.1.127 │├────────────────────────────────────────────────────────────────┤│ Subnet 3: 192.168.1.128/26 ││ Network: 192.168.1.128 ││ Usable: 192.168.1.129 – 192.168.1.190 ││ Broadcast: 192.168.1.191 │├────────────────────────────────────────────────────────────────┤│ Subnet 4: 192.168.1.192/26 ││ Network: 192.168.1.192 ││ Usable: 192.168.1.193 – 192.168.1.254 ││ Broadcast: 192.168.1.255 │└────────────────────────────────────────────────────────────────┘For router-to-router links requiring only 2 addresses, /30 (4 addresses, 2 usable) was traditional. RFC 3021 enabled /31 networks (2 addresses, both usable) by eliminating network/broadcast addresses on point-to-point links—doubling address efficiency for WAN connections.
Class C terminology and concepts permeate modern networking, even though CIDR has technically superseded classful addressing. The /24 boundary inherited from Class C remains the most common network size:
The /24 minimum routing requirement:
Most Internet backbone operators have policies rejecting routes more specific than /24 to prevent routing table explosion. This effectively makes /24 (a single Class C) the smallest independently routable block on the public Internet.
Implications:
In the IPv4 market, a single /24 (256 addresses) typically sells for $10,000-20,000 (2024 prices). This reflects both address scarcity and the /24's unique property of being independently routable—smaller blocks must be aggregated with a provider's space.
Class C completes the allocatable portion of the classful hierarchy—small networks designed for the numerous organizations that needed only modest IP capacity. Yet its limitations proved as instructive as its utility. Let's consolidate the key concepts:
What's next:
With Classes A, B, and C (the unicast allocation classes) complete, we'll explore Class D (Multicast) addresses—a fundamentally different addressing paradigm not for host identification but for group communication. You'll understand how addresses in the 224-239 range enable efficient one-to-many transmission without unicast replication.
You now possess comprehensive knowledge of Class C addressing: its binary structure, range boundaries, the 254-host limitation, private addressing (192.168.x.x), and ongoing significance as the /24 routing minimum. This understanding is essential for practical network design and troubleshooting.