IP addressing is the foundation of every network. Every device — a laptop, a server, an IoT sensor — needs an IP address to send and receive data. But the way those addresses are organized has changed fundamentally since the early internet. The original system, classful addressing, divided the address space into rigid classes and wasted enormous numbers of addresses. Its replacement, classless addressing (CIDR), introduced the flexibility that keeps IPv4 usable to this day and underpins how IPv6 is allocated.
This guide explains both systems clearly, shows why the shift happened, and covers the concepts a CCNA student needs to understand: the address classes, subnet masks, CIDR, VLSM, and private addressing.
Key takeaway: Classful addressing used fixed network classes with fixed masks, which wasted addresses. CIDR replaced it in 1993 with variable-length prefixes, letting networks be sized to actual need.
What is classful addressing?
The IETF defined the original IPv4 addressing scheme in RFC 791 (1981). The 32-bit address space was divided into five classes — A, B, C, D, and E — distinguished by the leading bits of the first octet. Three of these (A, B, C) were used for normal host addressing, each with a fixed default subnet mask: /8, /16, or /24. No other prefix lengths were allowed, and there was no way to nest or subdivide blocks flexibly.
The easiest way to identify an address’s class is by the first octet’s value. Here’s the structure:
| Class | First-octet range | Leading bits | Default mask | Networks | Hosts per network |
|---|---|---|---|---|---|
| A | 1–126 | 0 | 255.0.0.0 (/8) | 126 usable | 16,777,214 |
| B | 128–191 | 10 | 255.255.0.0 (/16) | 16,384 | 65,534 |
| C | 192–223 | 110 | 255.255.255.0 (/24) | 2,097,152 | 254 |
| D | 224–239 | 1110 | — (multicast) | — | — |
| E | 240–255 | 1111 | — (experimental) | — | — |
A few important reserved ranges sit inside this: 127.0.0.0/8 is reserved for loopback (local testing), 0.0.0.0 represents the default route, and 169.254.0.0/16 is reserved for link-local addresses (APIPA). This is why Class A has 128 possible network bit-combinations but only 126 usable networks — 0 and 127 are set aside.
The classes in detail
Class A (1.0.0.0–126.255.255.255): The high-order bit is 0, leaving 7 bits for the network portion — 128 combinations, 126 usable. Each network holds over 16 million hosts. These enormous blocks went to the earliest internet organizations. For example, MIT historically held 18.0.0.0/8 (and later sold off a large portion of it as IPv4 became scarce).
Class B (128.0.0.0–191.255.255.255): The leading bits are 10, and the first two octets form the network portion — about 16,000 networks of 65,534 hosts each. These went to universities and mid-sized organizations.
Class C (192.0.0.0–223.255.255.255): The leading bits are 110, and the first three octets form the network portion — over 2 million networks, but only 254 hosts each. Suited to small networks.
Class D (224.0.0.0–239.255.255.255): Leading bits 1110, reserved for multicast — one-to-many delivery to a group of hosts rather than a single destination. No subnet mask applies.
Class E (240.0.0.0–255.255.255.254): Leading bits 1111, reserved for experimental and future use. Not used for normal addressing.
Why classful addressing failed
The rigid class structure wasted addresses on a massive scale, because the jumps between classes were so large. Consider an organization that needed 500 hosts. A Class C (254 hosts) was too small, so it had to take a full Class B — 65,534 addresses — wasting over 64,000 of them. Multiply that inefficiency across thousands of organizations and the problem becomes clear.
By the early 1990s, a large share of Class B space had been allocated and IPv4 exhaustion was a real, looming threat. The rough proportional split of the address space made it worse: roughly half of all IPv4 space fell into Class A, a quarter into Class B, and an eighth into Class C, with the remainder in D and E. The allocation didn’t match real-world demand, so addresses ran short even though large blocks sat underused.
The birth of classless addressing (CIDR)
The solution arrived in 1993 with RFC 1519: Classless Inter-Domain Routing (CIDR). CIDR threw out the fixed classes entirely. Instead of A/B/C boundaries, a network is defined by an explicit prefix length — /8, /17, /26, or anything else — written after the address (for example, 192.168.1.0/24).
This unlocked two capabilities that fixed the waste:
Variable-Length Subnet Masking (VLSM) lets you subdivide a network into subnets of different sizes, each matched to its need. A /24 can be split into four /26 subnets, or into a mix of sizes — a /26 for a large LAN and several /30s for point-to-point links.
Route aggregation (supernetting) does the reverse: it combines multiple smaller networks into a single routing-table entry. For example, a single /16 advertisement can represent 256 contiguous /24 networks, dramatically shrinking the size of global routing tables.
A couple of quick examples of prefix notation:
- 192.168.1.0/24 = 254 usable hosts (mask 255.255.255.0)
- 10.0.0.0/16 = 65,534 usable hosts (mask 255.255.0.0)
With CIDR, a registry can hand an organization exactly the block it needs — two addresses, or two thousand — instead of forcing it into the next class up.
Public and private addresses
Public IP addresses are globally unique and routable across the internet. Any device directly reachable from the internet — a web server, a mail server — uses one, and no two devices worldwide share the same public address.
Private IP addresses, defined in RFC 1918, are reserved for internal networks and are not routable on the public internet. They can be reused freely inside any private network. Your home and office devices — laptops, phones, printers — typically use private addresses, reaching the internet through a router that performs Network Address Translation (NAT) to share one public address among many devices. The three private ranges are:
- 10.0.0.0/8 (10.0.0.0 – 10.255.255.255)
- 172.16.0.0/12 (172.16.0.0 – 172.31.255.255)
- 192.168.0.0/16 (192.168.0.0 – 192.168.255.255)
Classful vs. classless: side-by-side
| Feature | Classful | Classless (CIDR) |
|---|---|---|
| Structure | Fixed classes (A, B, C) | Custom prefix lengths (e.g. /24, /28) |
| Subnetting | Limited to default masks | VLSM allows variable-sized subnets |
| Efficiency | High waste | Sized to need, far less waste |
| Routing tables | Bloated by many allocations | Aggregation shrinks them |
| Scalability | Poor; contributed to IPv4 crisis | The basis of modern allocation |
| Modern use | Legacy references only | Standard everywhere |
Where things stand today: IPv4 exhaustion and IPv6
CIDR and NAT extended IPv4’s life by decades, but they couldn’t create new addresses — the 32-bit space holds only about 4.3 billion, for a world now connecting well over 15 billion devices. The result is that all five Regional Internet Registries have now exhausted their free IPv4 pools: IANA’s global pool ran dry in 2011, followed by APNIC (2011), ARIN (2015), RIPE NCC (2019), and LACNIC (2020), with only small reserves held back for IPv6-transition purposes.
Because no new IPv4 space is available from the registries, organizations that need it now buy or lease it on a secondary transfer market, where prices have run roughly in the range of $40–$60 per address in recent years. Providers also lean heavily on Carrier-Grade NAT (CGNAT) to share scarce public addresses among many customers — which works, but breaks end-to-end connectivity and complicates things like port forwarding.
The long-term fix is IPv6, which is inherently classless. Its 128-bit addresses (about 3.4 × 10³⁸ of them) eliminate the concept of classes entirely and typically use /64 prefixes for automatic address configuration (SLAAC). CIDR-style aggregation remains essential in IPv6 too, to keep global routing tables manageable given the vast address space. Adoption continues to climb but remains uneven across countries, so most networks run dual-stack (IPv4 and IPv6 together) or use translation mechanisms like NAT64 during the transition.
Why this matters for CCNA
Understanding the classful-to-classless shift isn’t just history — it’s the foundation of practical subnetting. The class structure explains why default masks are /8, /16, and /24, and CIDR/VLSM is what you actually use to design efficient networks. For hands-on practice, building and subnetting networks in a tool like Cisco Packet Tracer turns these concepts concrete, and it’s core exam material.
Frequently asked questions
What is the main difference between classful and classless addressing?
Classful addressing uses fixed classes (A, B, C) with fixed default masks, which wastes addresses. Classless addressing (CIDR) uses variable prefix lengths, so networks can be sized precisely to need.
Why did classful addressing lead to IPv4 exhaustion?
The large, fixed jumps between classes forced over-allocation — an organization needing 500 hosts had to take a 65,534-host Class B, wasting the rest. Across many organizations, this squandered enormous amounts of address space.
How does CIDR improve routing?
CIDR allows route aggregation: many contiguous networks can be advertised as a single prefix (e.g. one /16 covering 256 /24s), which keeps routing tables far smaller than they’d otherwise be.
Are private IP addresses still relevant?
Yes. The RFC 1918 ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) are used in virtually every home and office network, with NAT bridging them to the public internet. IPv6 has an equivalent concept in Unique Local Addresses (ULAs).
What role does VLSM play?
VLSM lets you subnet a network into different-sized pieces (for example, a /26 for a LAN and /30s for point-to-point links), maximizing efficiency — the direct answer to the waste that classful addressing caused.
Sources
- IETF — RFC 791 (Internet Protocol, 1981), RFC 1519 (CIDR, 1993), RFC 1918 (private addresses)
- APNIC — IPv4 exhaustion status and RIR depletion dates
- IANA / Regional Internet Registries — address allocation and reserved ranges (RFC 5735)
- Industry reporting on the IPv4 transfer market and per-address pricing (2026)
