- [Narrator] Let's take a look at some examples
not Class C.
Here I've got in this graphic
a network address of 172.16.0.0.
Notice this is an RFC 19/18 address for Class B 172.16
through 31 are my available networks
but in this case here we're using the first one.
My mask is 255.255.128
which is a slash 17
but the 128 here
isn't that important in the sense that we're Class B.
It doesn't make it any harder.
My subnets are in the third octet: zero and 128.
The fourth octet are all host bits.
So as you already know,
what do you do with host bits to get your network address?
You turn them all off.
To find your broadcast address,
what do you do with host bits?
You turn them all on.
So in this case here,
my fourth octet is all host bits so I just turn them all off
to get my network address and all on so the answer is:
zero and 255 in the fourth octet here always.
Okay, so my first subnet is zero.
My next subnet is 128.
So I put a 127 down here under the zero.
I add a dot zero and a dot 255 which is so easy to do.
My valid hosts are the numbers in between
which are zero dot one
through 127 dot 254 which is a tremendous amount of host.
It's actually 32,766 host which you could never implement.
Anyways my next subnet is 128 in the third octet.
My next block size of 128 is 256.
So the number right before that is 255
and I'll put that under the 128.
Add a dot zero and a 255
for all host bits off and on in the fourth octet.
My valid hosts are 128.1 to 255 to 254.
Lots and lots of hosts.
This would be
used mostly from an ISP than if they were using cable modems
or something like that.
You'll see in your neighborhood,
you'll have large mass like this.
As another example here we'll take a look at a
slash 20.
So in this graphic here,
you can see I'm using the Class B address of 172.16.0.0
but I have a 255.255 and then we have that
very important dot 240 dot zero
which is a slash 20.
So we have to remember this.
Now if I had the 240 in the fourth octet,
that would give me a slash 28 wouldn't it?
And we use that as an example.
But in this case here,
we have a block size 16 in my interesting octet.
The third octet.
My subnets are zero,
16, 32, and so on; all the way up to 240.
And then, so for example my first subnet is zero.
My next subnet is 16 in the third octet.
My interesting octet.
The number right before that is 15.
I just add all host bits off and on in the fourth octet
which is a zero there.
So there's no subnet bits in there, only host bits.
Turn them all off.
Turn them all on.
Now I have my first subnet which is zero dot zero,
broadcast centers 15.255.
My valid hosts are zero dot one through 15.254.
This gives me over 4,000 hosts per line.
That's an awful lot.
Nothing you can implement in an enterprise
or corporate environment.
Alright 16 is my next subnet in the third octet.
The next value is 32.
The number right before that is 31
so I put that under the 16.
Add my zero and 285 in the fourth octet
for all host bits off and on.
My valid hosts
are the numbers in between:
16.1 through 31.254.
Again, 4,000 hosts.
So these were two Class B examples
and as I've said Class A, B, or C,
it doesn't matter.
Look for your interesting octet.
Find your block size.
Count the increments to that block size.
You'll find your subnets.
The numbers right before the next subnet is always
your broadcast address
and your valid hosts are always the numbers
between your network address and broadcast address.