{"id":169034,"date":"2026-06-18T11:36:29","date_gmt":"2026-06-18T08:36:29","guid":{"rendered":"https:\/\/computingforgeeks.com\/?p=169034"},"modified":"2026-06-19T08:42:01","modified_gmt":"2026-06-19T05:42:01","slug":"ipv4-addressing-explained","status":"publish","type":"post","link":"https:\/\/computingforgeeks.com\/ipv4-addressing-explained\/","title":{"rendered":"IPv4 Addressing Explained: Classes, Private IPs & Cisco Setup"},"content":{"rendered":"\n

You sit down at a brand-new router, type show ip interface brief<\/code>, and every line says unassigned<\/code>. Before that box forwards a single packet it needs an IPv4 address, and before you can hand it one you need to know what the address actually means: which part identifies the network, which part identifies the device, and why some addresses you will never be allowed to assign.<\/p>\n\n\n\n

This guide explains how IPv4 addressing works from the ground up. We cover the 32-bit structure of an address, the A, B, and C address classes with their default masks, the difference between public and private (RFC 1918) addresses, and the exact commands to configure and verify an address on a Cisco router (and on a Windows, macOS, or Linux client<\/a>). Every value here is computed, and every command was run on a real IOS device so the output is the genuine article.<\/p>\n\n\n\n

Ran every command below on a Cisco IOS router (a GNS3 c7200) in June 2026, so the output you see is exactly what the device printed.<\/em><\/p>\n\n\n\n

If the IOS prompts and modes are still new, work through the IOS CLI editing basics<\/a> first. This guide assumes you can already move between user EXEC, privileged EXEC, and configuration mode.<\/p>\n\n\n\n

What an IPv4 address actually is<\/h2>\n\n\n\n

An IPv4 address is a 32-bit number, written as four 8-bit octets in dotted-decimal notation like 192.168.10.1<\/code>. Those 32 bits split into two parts: a network portion<\/strong> that identifies the network, and a host portion<\/strong> that identifies one device on it. The subnet mask is what marks the boundary between the two.<\/p>\n\n\n\n

Take 192.168.10.1<\/code> with mask 255.255.255.0<\/code>. The mask sets the first 24 bits as network and the last 8 bits as host, which is why you also see this written as 192.168.10.1\/24<\/code> in CIDR notation. The network is 192.168.10.0<\/code> and the host part is .1<\/code>.<\/p>\n\n\n\n

Property<\/th>Value<\/th><\/tr><\/thead>
Total length<\/td>32 bits<\/td><\/tr>
Structure<\/td>4 octets of 8 bits, dotted-decimal<\/td><\/tr>
Example address<\/td>192.168.10.1<\/td><\/tr>
Mask<\/td>255.255.255.0 (\/24)<\/td><\/tr>
Network portion<\/td>192.168.10.0 (first 24 bits)<\/td><\/tr>
Host portion<\/td>.1 (last 8 bits)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Seeing the same address broken into octets, then into binary, then against the mask makes the split obvious. The green octets are network, the amber octet is host, and the bottom row is the mask that draws the line:<\/p>\n\n\n\n

\"IPv4<\/figure>\n\n\n\n

A mask octet of 255<\/code> means all eight bits in that octet belong to the network; a 0<\/code> means all eight belong to the host. The host bits are the ones that change as you move from one device to the next on the same network.<\/p>\n\n\n\n

IPv4 address classes and their default masks<\/h2>\n\n\n\n

The class of an IPv4 address is decided by the value of its first octet alone. That single number tells you the historical default mask and how many hosts the network could hold.<\/p>\n\n\n\n

Class<\/th>First-octet range<\/th>Default mask<\/th>Network \/ host bits<\/th>Max hosts per network<\/th><\/tr><\/thead>
A<\/td>1 to 126<\/td>255.0.0.0 (\/8)<\/td>8 \/ 24<\/td>16,777,214<\/td><\/tr>
B<\/td>128 to 191<\/td>255.255.0.0 (\/16)<\/td>16 \/ 16<\/td>65,534<\/td><\/tr>
C<\/td>192 to 223<\/td>255.255.255.0 (\/24)<\/td>24 \/ 8<\/td>254<\/td><\/tr>
D<\/td>224 to 239<\/td>multicast, not assignable to hosts<\/td>n\/a<\/td>n\/a<\/td><\/tr>
E<\/td>240 to 255<\/td>reserved, not assignable to hosts<\/td>n\/a<\/td>n\/a<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Two ranges are carved out of Class A: 127.0.0.0<\/code> through 127.255.255.255<\/code> is reserved for loopback (that is why 127.0.0.1<\/code> always points back at the local host), and 0.0.0.0<\/code> is reserved. Classes D and E exist but you never put them on a host interface.<\/p>\n\n\n\n

One honest caveat: real networks have been classless since the 1990s. Modern routing uses the mask, not the class, to decide where the network ends, so a Class B address with a \/24 mask is perfectly normal. Classes still matter for the default-mask intuition and for reading older configurations, and they remain a Cisco CCNA exam topic, which is why they are worth knowing cold.<\/p>\n\n\n\n

Subnet ID, host range, and broadcast address<\/h2>\n\n\n\n

Inside any IPv4 network, two addresses are reserved and can never be assigned to a host: the subnet ID<\/strong> (the numerically lowest address in the range) and the directed broadcast<\/strong> (the numerically highest). Everything between them is a usable host address. The count of usable hosts is 2 raised to the number of host bits, minus those two reserved addresses, so the formula is (2^H) - 2<\/code> where H is the host bit count.<\/p>\n\n\n\n

For a \/24, H is 8, so usable hosts are (2^8) - 2 = 254<\/code>. The first usable address is the subnet ID plus one, and the last usable is the broadcast minus one. Here are two networks worked out the same way:<\/p>\n\n\n\n

Network<\/th>Subnet ID<\/th>First usable<\/th>Last usable<\/th>Broadcast<\/th>Usable hosts<\/th><\/tr><\/thead>
192.168.10.0\/24<\/td>192.168.10.0<\/td>192.168.10.1<\/td>192.168.10.254<\/td>192.168.10.255<\/td>254<\/td><\/tr>
172.16.1.0\/24<\/td>172.16.1.0<\/td>172.16.1.1<\/td>172.16.1.254<\/td>172.16.1.255<\/td>254<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

The second row is a Class B network (172.16.0.0) carrying a \/24 host mask, which produces 256 Class-C-sized subnets. Working those boundaries out for any mask is exactly what subnetting is. When you are ready for it, the step-by-step subnetting guide<\/a> walks the math, and the VLSM guide<\/a> shows how to size each subnet to its real host count.<\/p>\n\n\n\n

Public vs private IPv4 addresses, and why private exists<\/h2>\n\n\n\n

Public IPv4 addresses are globally unique and routable across the Internet; private addresses are free to reuse, never routed across the public Internet, and the reason your home and office networks all quietly share the same 192.168.x.x<\/code> space without colliding.<\/p>\n\n\n\n

The reason private addressing exists is simple arithmetic. IANA handed out its last block of public IPv4 space in early 2011, and the North American registry (ARIN) ran dry in 2015. Three things kept the Internet running past that wall: IPv6 (a vastly larger address space), CIDR (more efficient allocation), and NAT paired with private addresses. The private ranges are defined in RFC 1918<\/a>:<\/p>\n\n\n\n

Class<\/th>Private range<\/th>CIDR block<\/th>Networks<\/th><\/tr><\/thead>
A<\/td>10.0.0.0 to 10.255.255.255<\/td>10.0.0.0\/8<\/td>1<\/td><\/tr>
B<\/td>172.16.0.0 to 172.31.255.255<\/td>172.16.0.0\/12<\/td>16<\/td><\/tr>
C<\/td>192.168.0.0 to 192.168.255.255<\/td>192.168.0.0\/16<\/td>256<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

NAT is the bridge between the two worlds. A router translates a private inside address into a public address on the way out, so thousands of organizations can reuse the same 10.0.0.0\/8<\/code> internally because those packets never reach each other directly. ISPs typically filter RFC 1918 prefixes at the edge, so a misconfigured NAT that leaks a private source address usually gets its packets dropped rather than delivered.<\/p>\n\n\n\n

Configure an IPv4 address on a Cisco router<\/h2>\n\n\n\n

Assigning an address is three commands once you are at the interface: set the address and mask, bring the interface up, and leave configuration mode. From a fresh prompt:<\/p>\n\n\n\n

enable\nconfigure terminal\ninterface GigabitEthernet0\/0\nip address 192.168.10.1 255.255.255.0\nno shutdown\nend<\/code><\/pre>\n\n\n\n
The no shutdown<\/code> is the step that catches people. Cisco router interfaces are administratively down by default, so without it the address is configured but the interface never comes up. Confirm the address landed in the running configuration:<\/p>\n\n\n\n
show running-config | include ip address<\/code><\/pre>\n\n\n\n
The interface you just configured shows the address you set, while the interfaces you left alone still read no ip address<\/code>:<\/p>\n\n\n\n
 no ip address\n ip address 192.168.10.1 255.255.255.0\n no ip address\n no ip address<\/code><\/pre>\n\n\n\n
So far the address lives only in the running configuration, which is wiped on reload. Save it to the startup configuration so it survives a reboot:<\/p>\n\n\n\n
copy running-config startup-config<\/code><\/pre>\n\n\n\n
This is just the addressing slice of a full device bring-up. The complete first-boot workflow (hostname, secrets, SSH, console and VTY logins) is in the base device configuration guide<\/a>.<\/p>\n\n\n\n
Verify the address with show ip interface brief<\/h2>\n\n\n\n
The fastest way to confirm an address took effect is show ip interface brief<\/code>. It prints one line per interface with the address, how it was set, and the link state.<\/p>\n\n\n\n
show ip interface brief<\/code><\/pre>\n\n\n\n
GigabitEthernet0\/0 now carries 192.168.10.1<\/code>, the Method column reads manual<\/code> (the address was set by hand, not by DHCP), and both Status and Protocol are up<\/code>, which is the healthy state:<\/p>\n\n\n\n
Interface              IP-Address      OK? Method Status                Protocol\nEthernet0\/0            unassigned      YES unset  administratively down down\nGigabitEthernet0\/0     192.168.10.1    YES manual up                    up\nGigabitEthernet1\/0     unassigned      YES unset  administratively down down\nGigabitEthernet2\/0     unassigned      YES unset  administratively down down<\/code><\/pre>\n\n\n\n
Read the columns left to right: the interface name, its address, an OK flag, the Method (manual<\/code> for static, DHCP<\/code> if leased), then the Status (layer 1) and Protocol (layer 2) states. administratively down<\/code> means the interface is still shut, so it is the first thing to check when an address is set but nothing pings.<\/p>\n\n\n\n
For the full picture on a single interface, including the mask in CIDR form and the line rate, use show interfaces<\/code>:<\/p>\n\n\n\n
show interfaces GigabitEthernet0\/0<\/code><\/pre>\n\n\n\n
The first lines confirm the interface is up at gigabit speed and that the Internet address is 192.168.10.1\/24<\/code>, the CIDR form of the mask you typed:<\/p>\n\n\n\n
GigabitEthernet0\/0 is up, line protocol is up\n  Hardware is i82543 (Livengood), address is ca01.b2dc.0008 (bia ca01.b2dc.0008)\n  Internet address is 192.168.10.1\/24\n  MTU 1500 bytes, BW 1000000 Kbit\/sec, DLY 10 usec,\n     reliability 255\/255, txload 1\/255, rxload 1\/255\n  Encapsulation ARPA, loopback not set<\/code><\/pre>\n\n\n\n
Practice IPv4 addressing<\/h2>\n\n\n\n
Drill the facts with the flashcards, then check yourself on the quiz. The cards remember which ones you have marked as known, and you can grab the deck for Anki if you study with spaced repetition.<\/p>\n\n\n
Loading flashcards...<\/div><\/div>\n\n\n\n
Now test what stuck:<\/p>\n\n\n
Loading quiz...<\/div><\/div>\n\n\n\n
IPv4 addressing mistakes that trip people up<\/h2>\n\n\n\n
These are the snags that turn a five-minute task into a twenty-minute one, all of them seen on real gear.<\/p>\n\n\n\n
The address is set but the interface stays down.<\/strong> If show ip interface brief<\/code> shows administratively down<\/code>, the no shutdown<\/code> was skipped. If Status is up<\/code> but Protocol is down<\/code>, the problem is one layer lower: a missing cable, a speed or duplex mismatch, or the device on the other end is shut.<\/p>\n\n\n\n
Assigning the subnet ID or the broadcast to a host.<\/strong> In a \/24, the .0<\/code> and the .255<\/code> are reserved. The usable range runs from .1<\/code> to .254<\/code>. Hand a server 192.168.10.0<\/code> or 192.168.10.255<\/code> and it either refuses the address or talks to nothing.<\/p>\n\n\n\n
Thinking the address class still controls routing.<\/strong> It does not. The mask defines where the network ends, and the mask is independent of the class. A 172.x<\/code> address with a \/24 is a \/24 network, full stop, no matter what the old class tables say.<\/p>\n\n\n\n
Expecting a private address to work across the Internet.<\/strong> A 10.x<\/code>, 172.16-31.x<\/code>, or 192.168.x<\/code> address is typically filtered at the ISP edge. To reach the public Internet it has to be translated to a public address by NAT first. Internally it works perfectly; that is the whole point of RFC 1918.<\/p>\n\n\n\n
Get these four right and addressing stops being a mystery. The natural next step is sizing networks for a real host count, which is where subnetting and VLSM pick up. If you are studying for the CCNA, the CCNA 200-301 study roadmap<\/a> shows where addressing sits in the full path.<\/p>\n","protected":false},"excerpt":{"rendered":"
You sit down at a brand-new router, type show ip interface brief, and every line says unassigned. Before that box forwards a single packet it needs an IPv4 address, and before you can hand it one you need to know what the address actually means: which part identifies the network, which part identifies the device, … Read more<\/a><\/p>\n","protected":false},"author":3,"featured_media":169031,"comment_status":"open","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[299,55],"tags":[524,525],"cfg_series":[39888],"class_list":["post-169034","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-how-to","category-networking","tag-ccna","tag-cisco","cfg_series-ccna-200-301"],"_links":{"self":[{"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/posts\/169034","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/comments?post=169034"}],"version-history":[{"count":1,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/posts\/169034\/revisions"}],"predecessor-version":[{"id":169054,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/posts\/169034\/revisions\/169054"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/media\/169031"}],"wp:attachment":[{"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/media?parent=169034"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/categories?post=169034"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/tags?post=169034"},{"taxonomy":"cfg_series","embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/cfg_series?post=169034"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}