Isolating bits and bytes

Task: Create a program that manages an IP address. Allow the user to enter the IP address as four 8 bit unsigned integer values (just use 4 sequential CIN statements). The program should output the IP address upon the users request as any of the following. As a single 32 bit unsigned integer value, or as four 8 bit unsigned integer values, or as 32 individual bit values which can be requested as a single bit by the user (by entering an integer 0 to 31). Or as all 32 bits assigned into 2 variable sized groups (host group and network group) and outputted as 2 unsigned integer values from 1 bit to 31 bits each.

Example functionality:

Enter and IP address:

192

168

1

5

Scenario 1:

How would you like to see your IP address ((1) single value, (2) four values, (3), two values, (4) a single bit value): 1

Output should be 3232235781

Scenario 2:

How would you like to see your IP address ((1) single value, (2) four values, (3), two values, (4) a single bit value): 2

Output should be 192.168.1.5

Scenario 3:

How would you like to see your IP address ((1) single value, (2) four values, (3), two values, (4) a single bit value): 3

How many bits in the network address: 16

Output should be 49320, 261

Scenario 4:

How would you like to see your IP address ((1) single value, (2) four values, (3), two values, (4) a single bit value): 4

Which bit would you like to see: 21

Output should be 1

(Because the binary of the IP address is 11000000101010000000000100000101

This lab deals with the following concepts:

Bit fields

Unions

Bit masking

IP addressing (for the sake of creating a useful program)

Bit Fields

The smallest memory size of any built in C data type is 1 byte. Even the Boolean data type requires one byte of memory. But C++ allows for a special type of variable field called a bit field, which can only be declared in a structure. A structure is a data structure which stores one to many consecutive values on any data type. For example, the following structure could be used to store a birth date, rather than just using three separate variables:

struct birth_date {

int day;

int month;

int year;

};

So structures are kind of like classes with no methods or constructors. You would declare a variable of the birth_date structure type and assign values to its members as follows:

birth_date b;

b.day=5;

b.month=12;

b.year=1973;

Members of a structure can have an extra parameter in there declaration and become bit fields. Rather than just using standard byte offsets for datatypes (e.g.,, int(4 bytes), short(2 bytes), char(1 byte), bool(1 byte)), members of a structure can be assigned any number of bits (as low as 1 bit!). For example, to store a day of the month the maximum number would be 31, which really only requires 5 bits. The month value should only require 4 bits. The year may require, lets say, up to 16 bits. So you can declare bit fields within a structure as follows:

struct birth_date {

int day : 5;

int month : 4;

int year : 16;

};

The structure works the same way as before.

Unions

Unions are one of the most useful features of C++, especially to an engineer (we are in a computer engineering class). Unions allow the same memory space to be shared by multiple variables (NOT like pointers). Yes, you could do something simple like this:

union value {

unsigned int me;

unsigned int you;

};

value v;

v.you=5;

cout<

In that example, me and you are basically the same thing. Just two different ways of referencing the same memory space and the same value. The cout statement would print 5. I suppose that could be useful, but the real use comes when you use different sized sequential datatypes in a union (this requires a structure for at least one union member):

struct youandme {

unsigned short you;

unsigned short me;

};

union value {

youandme you_me;

unsigned int us;

};

The union value is a 32 bit field. It can be referenced by a single 32 bit value called us, or by its two 16 bit halves called you (the 16 least significant bits) and me (the 16 most significant bits). The following sets the whole 32 bit value to 5:

value v;

v.us = 5;

If you look at the binary value of v it is 00000000000000000000000000000101

Now if you perform:

v.you_me.me = 5;

You have just changed the high order 16 bits to 5. So if you look at the binary value of v it is 00000000000001010000000000000101

So the value of v has changed to 327685. Pretty cool right? You can also rewrite this structure using bit fields:

struct youandme {

unsigned int you : 16;

unsigned int me : 16;

};

union value {

youandme you_me;

unsigned int us;

};

Bit Masks

Unfortunately, you cannot use arrays of bit fields in a union, so if you wanted to reference all bits individually, you would need to do so with static bit fields:

struct bits {

unsigned int a1 : 1;

unsigned int a2 : 1;

...

unsigned int a32 : 1;

};