Chap.

2. Intro. To Data
Structures &
ADTs – C-Style Types
• Goal: to organize data
• Criteria: to facilitate efficient
– storage of data
– retrieval of data
– manipulation of data
• Design Issue:
– select and design appropriate data
types.
(This is the real essence of OOP.)
1
 Examples – Factors to Consider
Airline Reservations Trans-Fryslan Airlines (pp. 30-31)
Lab 2A Attempt 1:
enum SeatStatus {OCCUPIED, UNOCCUPIED};
SeatStatus seat1, seat2, . . . , seat10;
 Horrible algorithms for the basic operations!
Attempt 2:
const int MAX_SEATS = 10;
// upper limit on number of seats
enum SeatStatus {OCCUPIED, UNOCCUPIED};
typedef SeatStatus SeatList[MAX_SEATS];

SeatList seat;
 Nice algorithms for the basic operations!

Tradeoff: simplicity of data organization  simplicity/elegance of algorithms

Simple (unsophisticated data structure)

may require much work for processing data.
More complex data organization
may yield nicer algorithms for the basic operations 2
 Examples - cont.
Searching an online phone directory: Linear search?
OK for Calvin College
too slow for Grand Rapids or New York
 Amount of data is an important factor.
or
Restructure (order) the data set for efficient processing interpolation search
use binary search or an indexed sequential search

Compiler lookup of an identifier's type, etc. in a symbol table:

Linear search? No, too slow
Binary search? No, too much work to keep sorted
 Number of accesses & speed required is an important factor.
Use hash tables

Text processing: Store in an array / vector?

OK for text analysis — word counts, average word length, etc.
Not for word-processing — Too inefficient if many insertions
& deletions
 Static vs. dynamic nature of the data is an important factor
3
 Abstract Data Type
Def.
(ADT)
a collection of related data
items
together with
an associated
e.g. whole set ofand
numbers (integers) operations
arithmetic operators
for addition, subtraction, multiplication and division.

e.g. Seats for TFA

Basic operations: find empty seat, reserve a seat,
cancel a seat assignment
Why "abstract?"
Data, operations, and relations are studied
independent of implementation.

What not how is the focus.

4
 Implementation of an
Def.Consists of
ADT
storage structures (aka data
structures)
to store the data items
and
algorithms for the basic operations.

The storage structures/data structures used in

implementations are provided in a language (primitive
or built-in) or are built from the language constructs
(user-defined).

In either case, successful software design uses data

abstraction:
5
Separating the definition of a data type from its
 C++ Types

Fundamental Types Structured Types

array
Arithmetic void pointers struct
union
class
istream
ostream
Integral Floating point bool complex iostream
(reals) ifstream
ofstream
istringstream fstream
string
Characters Enumerations Integers float ostringstream vector
double stringstream deque
long double list
int stack
char queue
unsigned char short int
long int priority_queue
signed char map
unsigned
unsigned short multimap
set
unsigned long multiset
bitset
valarray
6
 Simple Data Types (§2.2)
Memory:
2-state devices  bits 0 and 1

Organized into bytes (8 bits) and

words (machine dependent — e.g., 4 bytes).

Each byte (or word) has an address making it possible to store

and retrieve contents of any given memory location.
Project 1
(See App. B re
Therefore: base 2, 8, 16)

the most basic form of data: sequences of bits

 simple data types (values are atomic — can't be subdivided) are
ADTs. characters
Implementations have: integers
reals
» Storage structures: memory locations logical
» Algorithms: system hardware/software to do basic
operations. 7
 Boolean data
Data values: {false, true}


In C/C++: false = 0, true = 1 (or nonzero)

Could store 1 value per bit, but usually use a byte

(or word)
Operations: and && (See bit tables on p. 
34)
or ||
not !
||
x !x
0 1
1 0
&&
8
 Character Data
Store numeric codes (ASCII, EBCDIC, Unicode)
1 byte for ASCII and EBCDIC,
App. A 2 bytes for Unicode (see examples on p. 35). Java

Basic operation: comparison to determine if ==, <, >, etc.

9
use their numeric codes (i.e. use ordinal value)
 Integer Data
Nonegative (unsigned) integer:
type unsigned (and variations) in C++
Store its base-two representation in a fixed number w
App. Bof bits
(e.g., w = 16 or w = 32)
00000000010110002
88 =

Signed integer: type int (and variations) in

C++
Store in a fixed number w of bits using one of
the following representations:
10
 Sign-magnitude representation

Save one bit (usually most significant) for

sign
(0 = +, 1 = – )

Use base-two representation in the other

bits. 0

88 sign
_000000001011000
bit

1
–88 _000000001011000

Cumbersome for arithmetic

computations

11
 Two's complement
representation Same as
For nonnegative n: sign mag.
Use ordinary base-two representation with leading (sign) bit 0

For negative n (–n):

(1) Find w-bit base-2 representation of n WHY?
WHY?
(2) Complement each bit.
(3) Add 1 (Flip all bits from rightmost 0 to
the end)
Example: –88
1. 88 as a 16-bit base-two number000000000101100
2. Complement this bit 111111111010011
0
3. Add 1
string 111111111010100
0

12
Good for arithmetic computations (see p. 38)

These work for both + and – integers

5 + 7:
111 carry bits
0000000000000101
+0000000000000111
000000000000
1100
5 + –6:
0000000000000101
+1111111111111010
111111111111
1111 13
 Biased representation
Add a constant bias to the number (typically, 2w – 1) ;
then find its base-two representation.
Examples:
88 using w = 16 bits and bias of 215 = 32768
1. Add the bias to 88, giving 32856
2. Represent the result in base-two notation:
1000000001011000

Note: For n > 0, just change leftmost bit of binary

representation of n to 1

–88:
1. Add the bias to -88, giving 32680
2. Represent the result in base-two notation:
01111111101010
00
 Good for comparisons; so, it is commonly used for
exponents in floating-point representation of reals. 14
 Problems with Integer
Representation

Limited Capacity — a finite number of bits

An operation can produce a value that requires more bits

than maximum number allowed.
See climits
This is called (App. C)
overflow .
What's
INT_MAX + 1?

So none of these is a perfect representation of (mathematical)

integers — can only store a finite (sub)range of them.

15
 Real Data
T y p e s f l o a t a n d d o u b l e ( a n d v a r ia tio n s ) in C + +
S in g le p r e c is io n ( I E E E F lo a tin g - P o in t F o r m a t ) p. 756
1 . W rite b in a r y r e p r e s e n ta tio n in f lo a tin g -p o in t fo r m :
b 1 .b 2 b 3 . . .  2 w ith e a c h b i a b it a n d b 1 = 1 ( u n le s s n u m b e r is 0 )
k


m a n tis s a exponent
o r fra c tio n a l p a r t
double:
2. Store: Exp: 11 bits,
bias
— sign of mantissa in leftmost bit (0 = +, 1 = – )
1023
— biased binary rep. of exponent in next 8 bits (bias = 127)Mant: 52 bits
— bits b2b3 . . . in rightmost 23 bits. (Need not store b1 — know
it's 1)
Example: 22.625 = 10110.10 (see
p.41) 12 1.01101012
Floating point form:
24 +
127
16
 Problems with Real
What's Representation
10*DBL_MAX? See cfloat
(App. C)
Exponent overflow/underflow (p. 41)
Only a finite range of reals can be stored exactly.

Roundoff error (pp. 41-42)

Most reals do not have terminating binary representations. p. 756
Example:
0.7 = (0.101100110011001100110011001100110 . . .)2
e.g., 44.7

Roundoff error may be compounded in a sequence of operations.

Be careful in comparing reals with == and !=.

17
 C-Style Data Structures: Arrays
(§2.3)
Defn of an array as an ADT:
An ordered set (sequence) with a fixed number of
elements,
where the basic
all of the sameoperation
type, is
direct access to each element in the array so values
can be
retrieved from or stored in this element.
Properties:
• Ordered so there is a first element, a second one, etc.
• Fixed number of elements — fixed capacity
• Elements must be the same type (and size);
 use arrays only for homogeneous data sets.
• Direct access: Access an element by giving its location
— the time to access each element is the same for all
elements,
regardless of position. 18
 Declaring arrays in C++
element_type array_name[CAPACITY];
where
element_type is any type
array_name is the name of the array — any valid identifier
CAPACITY (a positive integer constant) is the number of
elements in the array Can't input the capacity
The compiler reserves a block of consecutive memory locations, enough
to hold CAPACITY values of type element_type.
The elements (or positions) of the array are indexed 0, 1, 2, . . .,
CAPACITY - 1.
e.g., double score[100]; score[0]
Better to use a named constant to specify the array capacity:
score[1]
const int CAPACITY = 100; score[2]
double score[CAPACITY]; score[3]
. .
Can use typedef with array declarations; e.g., . .
. .
const int CAPACITY = 100;
typedef double ScoresArray[CAPACITY]; score[99]
ScoresArray score;
19
 How well does C/C++ implement an array ADT?

As an ADT In C++

ordered indices numbered 0, 1, 2, . . .,

fixed size CAPACITY -specifies
CAPACITY 1 the capacity of the
array
same type element_type is the type of
elements elements
subscript operator
direct access []

20
 Subscript operator
[] is an actual operator and not simply a notation/punctuation as in some
other languages.
Its two operands are an array variable and an integer index (or
subscript) and is written
array_name[i] Also, it
Here i is an integer expression with 0 < i < CAPACITY – 1. can have
an index
[] returns the address of the element in location i in array_name; so
array_name[i]is a variable, called an indexed (or subscripted)
variable,
whose type is the specified element_type of the array.
This//means thatall
Zero out it can
thebeelements
used on of
thescore
left side of an assignment, in input
statements,
for (int etc.
i = to0; store a value in i++)
i < CAPACITY; a specified location in the array. For
example:
score[i] = 0.0;
// Read values into the first numScores elements of score
for (int i = 0; i < numScores; i++)
cin >> score[i];
// Display values stored in the first numScores elements
for (int i = 0; i < numScores; i++)
cout << score[i] << endl; 21
 Array Initialization
In C++, arrays can be initialized when they are declared.
an array literal
Numeric arrays:
element_type num_array[CAPACITY] = {list_of_initial_values};
Example:
double rate[5] = {0.11, 0.13, 0.16, 0.18, 0.21};
0 1 2 3 4
rate 0.11 0.13 0.16 0.18 0.21

Note 1: If fewer values supplied than array's capacity, remaining

elements assigned 0. What’s
double rate[5] = {0.11, 0.13, 0.16}; an easy
way to
0 1 2 3 4 initialize
an array
rate 0.11 0.13 0.16 0 0 to all
zeros?

Note 2: It is an error if more values are supplied than the declared size
of the array.
How this error is handled, however, will vary from one compiler to
another. 22
Character arrays:
Character arrays may be initialized in the same manner as
numeric
chararrays.
vowel[5] = {'A', 'E', 'I', 'O', 'U'};

declares vowel to be an array

0 of 52characters
1 3 4 and initializes it as
follows: vowel A E I O U

Note 1: If fewer values are supplied than the declared size of the
array,
the zeroes used to fill uninitialized elements are interpreted as
the null character '\0' whose ASCII code is 0.

const int NAME_LENGTH = 10;

char collegeName[NAME_LENGTH]={'C',
0 1 2 3 4 5'a',
6 'l',
7 8'v',
9 'i', 'n'};
collegeName C a l v i n \0 \0 \0 \0
23
Note 2: Character arrays may be initialized using string
constants. For example, the following declaration is
equivalent to the preceding:
char collegeName[NAME_LENGTH] = "Calvin";
Note 3: The null character '\0' (ASCII code is 0) is used
as an end-of-string mark.

Thus, character arrays used to store strings should be declared

large enough to store the null character. If it is not, one
cannot expect some of the string functions and operations See to
cstring
work correctly. in App. D; also
>> and <<
If a character array is initialized with a string constant, the
end-of-string mark is added automatically, provided there is
room for it.

char collegeName[7] = {'C', 'a', 'l', 'v', 'i', 'n', '\0'};

char collegeName[7] = "Calvin";
24
 Initializations with no array size
specified
The array capacity may be omitted in an array declaration
with an initializer list.

In this case, the number of elements in the array will be

the number of values in the initializer list.

Example:
double rate[] = {0.11, 0.13, 0.16};
0 1 2
rate 0.11 0.13 0.16

Note: This explains the brackets in constant declarations

such as
25
const char IN_FILE[] = "employee.dat";
 Addresses
When an array is declared, the address of the first byte (or word)
in the block of memory associated with the array is called the
base address of the array.
Each array reference must be translated into an offset from this
base address.
For example, if each element of array score will be stored in 8
cout << score[3] << endl;
bytes and the base address of score is 0x1396.
score A0x1396
statement such
requires that array reference [0]
as [1]
score[3]
be translated into a memory [2]
score[3]  0x1396 + 3 * (sizeof
address: 0x13a [3]
.
double) e .. .
. .
= 0x1396 + 3 * 8
= 0x13ae [99]
The contents of the memory word with this
address 0x13ae can then be retrieved and
displayed.
26
An address translation like this is carried
The value of array_name is actually the base address of
array_name
array_name + index is the address of array_name[index].
Lab
2B

*(array_name + index)
An array reference array_name[index]
* is the dereferencing
is equivalent to operator
*ref returns the contents of the memory location with
address ref

For example, the following statements are equivalent:

cout << score[3] << endl;

cout << *(score + 3) << endl;

Note: No bounds checking of indices is done! (See pp. 50-51)

27
C-Style Multidimensional
Arrays
Example: A table of test scores for several different
students on p.52
several different tests.
Test 1 Test 2 Test 3 Test 4
Student 1 99.0 93.5 89.0 91.0
Student 2 66.0 68.0 84.5 82.0
Student 3 88.5 78.5 70.0 65.0
: : : : :
: : : : :
Student-n 100.0 99.5 100.0 99.0

For storage and processing, use a two-dimensional

array.

28
 Declaring Two-Dimensional
Arrays
Standard form of declaration:
element_type array_name[NUM_ROWS][NUM_COLUMNS];
[0] [[1] [2]
Example: [0] [3]
[1]
[2]
const int NUM_ROWS = 30, [3]
NUM_COLUMNS = 4;
double scoresTable[NUM_ROWS][NUM_COLUMNS]; [29]
or
typedef double TwoDimArray [NUM_ROWS][NUM_COLUMNS];
TwoDimArray scoresTable;
Initialization
 List the initial values in braces, row by row;
 May use internal braces for each row to improve
readability.
Example:
double rates[2][3] = {{0.50, 0.55, 0.53}, // first row
29
{0.63, 0.58, 0.55}}; // second row
 Processing Two-Dimensional
Arrays
 Remember: Rows (and) columns are numbered from zero!!

 Use doubly-indexed variables:

scoresTable[2][3] is the entry in row 2 and column
3 Countin
g from 0

row index column index
 Use nested loops to vary the two indices, most often in a rowwise
manner.
int numStudents, numTests, i, j;
cout << "# students and # of tests? ";
cin >> numStudents >> numTests;
cout(i
for <<="Enter
0; i <test scores for
numStudents; students\n";
i++)
{
cout << '#' << i + 1 << ':';
for (j = 0; j < numTests; j++)
cin >> scoresTable[i][j];
30
}
 Higher-Dimensional Arrays

The methods for two-dimensional arrays extend in the obvious way.

Example: To store and process a table of test scores for several differe
students on several different tests for several different semesters

const int RANKS = 10, ROWS = 30, COLUMNS = 4;

typedef double ThreeDimArray[RANKS][ROWS][COLUMNS];
ThreeDimArray gradeBook;

is the score on page 4 for student 2 on test 3

gradeBook[4][2][3]

// number of pages, students and tests all counted from zero!!

31
 Errors in
b. Still higher dimensions text
Example like the automobile-inventory example on pp. 54-5

enum BrandType {Levi, Wrangler, CalvinKlein, Lee,

BigYank, NUM_BRANDS};
enum StyleType {baggy, tapered, straightleg, designer,
NUM_STYLES};
enum WaistType {w28, w29, w30, w31, w32, w33, w34, w35,
w36, w37, w38, w39, w40, w41, w42, w43,
w44, w45, w46, w47, w48, NUM_WAIST_SIZES};
enum InseamType {i26, i27, i28, i29, i30, i31, i32,
i33, i34, i34, i36, NUM_INSEAM_SIZES};
typdef int
JeansArray[NUM_BRANDS][NUM_STYLES]
[NUM_WAIST_SIZES][NUM_INSEAM_SIZES];
JeansArray jeansInStock;

jeansInStock[b][s][w][i]--;
// sale of 1 brand-b, style-s, waist-w, inseam-i jeans
32
 Arrays of Arrays
[0] [[1] [2]
[0] [3]
[1]
[2]
[3]
double scoresTable[30][4];
[29]

clares scoresTable to be a one-dimensional array containing

elements, each of which is a one-dimensional array of 4 real numbers;
oresTable is a one-dimensional array of rows , each of which has 4
al values. We could declare it as
[0] [[1] [2]
[0] [3]
typedef double RowOfTable[4]; [1]
[2]
RowOfTable scoresTable[30];
[3]

or, since typedef is used once, why not use it

twice: [29]
typedef double RowOfTable[4];
typedef RowOfTable TwoDimArray[30];
TwoDimArray scoresTable;
33
 In any case:
scoresTable[i] is the i-th row of the table
scoresTable[i][j] should be thought of as (scoresTable[i])[j]
that is, as finding the j-th element of scoresTable[i].

Address Translation:
The array-of-arrays structure of multidimensional arrays explains
address translation.
Suppose the base address of scoresTable is 0x12348:
[0]
scoresTable[10] [1]
[3]
scoresTable[10]  0x12348 + 10*(sizeof
RowOfTable)
= 0x12348 + 10 * (4 * 8)
[9] [3]
scoresTable[10] [10
]
[3]  base(scoresTable[10]) + 3*(sizeof
= 0x12348 + 10 * (4 * 8)
double)
+3*8
= 0x124a0
In general, an n-dimensional array can be viewed (recursively) as a
34
one-dimensional array whose elements are (n - 1)-dimensional
 Arrays as Parameters
Passing an array to a function actually passes the
base address
of1.the
Thearray. This means:
parameter has the same address as the
argument.
So modifying the
parameter will f(array); void f(ArrayType param)
{ ... }
modify the
corresponding
array argument.
2. Array capacity is not available to a function unless
passed as a separate parameter.
The following function prototypes are all equivalent
void Print(int A[100], int theSize);
void Print(int A[], int theSize);
void Print(int * A, int theSize); 35
 Arrays as Parameters …
Continued
Now, what about multidimensional arrays?

void Print(double table[][], int rows, int cols)

doesn't work

Use a typedef to declare a global type identifier and use it to

declare
the types of the parameters.
By #includes
For example: (so global)

typedef double TwoDimArray[30][4];

. . .
TwoDimArray scoresTable;
. . .
void Print(TwoDimArray table, int rows, int col)
. . . 36
Problems with C-Style Arrays

•Capacity cannot change.

Later
Solution 1 (non-OOP) Use a run-time array
— Construct B to have required capacity
— Copy elements of A into B
— Deallocate A

Solution 2 (OOP) Use vector

37
 Start Stop
processing processing
•Virtually no predefined here here
operations
for non-char arrays. J o h n D o e \0 \0
Basic reason: No character
to mark the end of a Start Stop
processing processing
numeric sequence here where???
— no numeric equivalent
of the NUL character. 6 2 0 1 5 0 2 0 0 0
Solution 1(non-OOP): In addition to the array,
pass its size (and perhaps its capacity) to
functions.
The Deeper
Problem:
C-style arrays aren't self-
contained.
Basic principle of OOP:
An object should be autonomous (self-contained); it should
carry within itself all of the information needed to describe and
operate upon itself.

Solution (OOP): Encapsulate array, capacity, size, and 38

Array in Java
operations
 Aggregate Data Types

Why Needed?
Current OCD:
1. Identify the objects in the problem.
1a. . . .
2. Identify the operations in the problem.
2a. If the operation is not predefined, write a function to
perform it.
2b. If the function is useful for other problems, store it in a
library.
3. Organize the objects and operations into an algorithm.
4. Code the algorithm as a program.
5. Test, execute, and debug the program.
But,
6. predefined types
Maintain the may not be adequate; so we add:
program
1a. If necessary, create a new data type to model it.
39
Especially true if object being modeled has multiple
attributes.
Examples:
A temperature has:
 a degrees attribute
 a scale attribute (Fahrenheit, Celsius, Kelvin)
32 F
degrees
scale
A date has:
 a month attribute
 a day attribute
 a year attribute

February 14 2001
month day year

40
C++ provides structs and classes to create new
types with multiple attributes.

So we add to our OCD methodology:

1a. If necessary, create a new data type to

model it.

1b. If the object has multiple attributes, create a

struct or class to represent objects of that
type.

41
As an
ADT:
A structure (usually abbreviated to struct and sometimes
called a record)
 has a fixed size Only difference
from an array
 is ordered
 elements may be of different types

The basic operation is direct access to each element so that

values can be stored in / retrieved from that element.
Declaration (C-
Style)
struct TypeName
{
TypeA data1;
TypeB data2;
... //member data of any type
};

42
 Examples:
32 F
degrees
scale struct Temperature
{
double degrees; // number of degrees
char scale; // temp. scale (F, C, or K)
};
Temperature temp;

February 14 2001
month day year
struct Date
{
char month[10]; string month; // name of month
int day, // day number
year; // year number
};
Date birthday, currentDate; 43
Phone Listing:
John Q. Doe 12345 Calvin Rd. Grand Rapids, MI 9571234
name street city & state
phone #
struct DirectoryListing
{
char name[20],
string name, // name of person
street[20],
street, // street address
cityAndState[20];
cityAndState; // city, state (no zip)
unsigned phoneNumber; // 7-digit phone number
};

DirectoryListing
entry, // entry in phone book
group[20]; // array of directory listings

44
Coordinates of a point: Test scores:
(Members need not (Members may be structured
have different types.) types — e.g., arrays.)

3.73 –2.51 012345 83 79 92 85

x coord. y coord. id-number list of
struct Point scores
struct TestRecord
{ {
double xCoord, unsigned idNumber,
yCoord;
};
score[4];
};
Point p, q;
TestRecord studentRecord,
gradeBook[30];

45
 Hierarchical (or nested) structs
Since the type of a member may be any type,
it may be another struct.
John Q. Doe 123 Calvin Rd. Detroit, MI 95714 May 17 1975 3.95 92.5
name street city & state -zip month
day year gpa credits
DirectoryListing Date real

struct PersonalInfo
{
DirectoryListing ident;
Date birth;
double cumGPA,
credits;
};
PersonalInfo student; 46
Some Properties:
The scope of a member identifier is the struct in which it is
defined.
Consequences:
— A member identifier may be used outside the struct for
some other purpose.
e.g. int month; // legal declaration alongside Date

— A member cannot be accessed outside the struct just by

giving its name.
e.g. year will not yield anything unless there is a year
Directdeclared outside
access to the Date
members struct.(or class) is
of a struct
implemented using
member access operators: one of these is the dot
operator (.)
struct_var.member_name

47
Examples:
Input a value into the month member of birthday
cin >> birthDay.month;

Calculate y coordinate of a point on y = 1/x

if (p.xCoord != 0)
p.yCoord = 1.0 / p.xCoord;

Sum the scores in studentRecord

double sum = 0;
for (int i = 0; i < 4; i++)
sum += studentRecord.score[i];
Output the name stored in student
cout << student.ident.name << endl

48
A Quick Look at Unions (p. 68)

Declaration: Like a struct, but replace "struct" with "union":

union TypeName TypeName is optional
{
declarations of members //of any types
};

A union differs from a struct in that the members

share memory. Memory is (typically) allocated
for the largest member, and all the other members
share this memory

49
Unions can be used to define structs that have some
common members — a fixed part — and a variant
part that makes it possible for the fields of a struct to
differ from one data value to the next. For example to
process a file of information about various categories
of people:
John Doe 40 M <——— name, age, marital status
(married)
January 30 1980 <——— wedding date
Mary Smith Doe 8 <——— spouse, # dependents
Fred Jones 17 S <——— name, age, marital status (single)
T <——— available
Jane VanderVan 24 D <——— name, age, marital status
(divorced)
February 21 1998 N <——— divorce date, remarried (No)]
Peter VanderVan 25 W <——— name, age, marital status
(widower)
February 22 1998 Y <——— date became a widower, 50

remarried (Yes)
struct Date struct PersonalInfo
{ {
string month; string name;
short day, year; short age;
}; char marStatus;
struct MarriedInfo // Tag: S = single, M = married,
{ // W = was married
Date wedding; union
string spouse {
short dependents; MarriedInfo married;
}; SingleInfo single;
struct SingleInfo WasMarriedInfo wasMarried;
{ };
bool available; };
};
PersonalInfo person;
struct WasMarriedInfo
{
Date divorceOrDeath;
char remarried;
};
51
Structs with variant parts aren't used much anymore.
(p. 69)
Instead, in OOP languages:
 Encapsulate the common information in a base class.

 Use inheritance to build derived classes for the variants

(Derived classes inherit all of the members of the base class.)
PersonalInfo
name
base class age
marStatus

name name name

age age age
derived classes marStatus marStatus marStatus

wedding available divorceOrDeath

spouse remarried
SinglePerson
dependents WasMarriedPerson
MarriedPerson
52
 Address translation for structs and unions is similar
to that for arrays, except that different field types
require using a summation to calculate the offsets.
(p. 70)
If a struct s has fields f1, ..., fn, requiring w1, ..., wn cells of storage,
respectively:

Address of s.fk = base address of s + offset

k 1

= base address of s w
+i i 1

For structs that contain unions: Allocate space

for the largest variant, and then overlay variants
in this space. 53
 A commercial for OOP: Two programming
paradigms
• Procedural: ( C, FORTRAN, • Object-oriented: ( C++,
and Pascal ) Java, and
– Action-oriented — concentrates Smalltalk)
on the verbs of a problem's
specification
– Focuses on the nouns of a
– Programmers: problem's specification
• Identify basic tasks to be – Programmers:
performed to solve problem
• Determine what objects
• Implement the actions are needed for a problem
required to do these tasks as and how they should work
subprograms together to solve the
(procedures/functions/ problem.
subroutines)
• Group these subprograms into • Create types called classes
programs/modules/libraries, made up of data members
which together make up a and function members to
complete system for solving operate on the data.
the problem Instances of a type (class)
are called objects.
54
Creating a Data Type in a procedural (C-type) language
(See pp. 74-78)

Problem: Create a type Time for processing times in standard

hh:mm
AM/PM form and in military-time form.
Data Members:
Hours (1, ..., 12)
Minutes (0, 1, 2, ..., 59)
AM or PM indicator ('A' or 'P')
MilTime (military time equivalent)
Some Operations :
1. Set the time
2. Display the time
Implementation:
3. Advance the time
1.
4. Need storage
Determine for time
if one the data members
is less — usetime.
than another a
struct
2. Need functions for the operations.
55
3. "Package" declarations of these together in a
/** Time.h ----------------------------------------------------------
This header file defines the data type Time for processing time.
Basic operations are:
Set: To set the time
Display: To display the time
Advance: To advance the time by a certain amount
LessThan: To determine if one time is less than another
--------------------------------------------------------------------*/

#include <iostream> Notice the

using namespace std;
documentation
!
struct Time
{
unsigned hour,
minute;
char AMorPM; // 'A' or 'P'
unsigned milTime; // military time equivalent
};

56
/* Set sets the time to a specified values. Notice
* the docu-
* Receive: Time object t mentatio
* hours, the number of hours in standard time n!
* minutes, the number of minutes in standard time
* AMPM ('A' if AM, 'P' if PM
* Pass back: The modified Time t with data members set to
* the specified values
******************************************************************/
void Set(Time & t, unsigned hours, unsigned minutes, char AMPM);

/* Display displays time t in standard and military format using

* output stream out.

* Receive: Time t and ostream out

* Output: The time T to out
* Pass back: The modified ostream out
******************************************************************/
void Display(const Time & t, ostream & out);

/* Advance increments a time by a specified value.

*
* Receive: Time object t
* hours, the number of hours to add
* minutes, the number of minutes to add
* Pass back: The modified Time t with data members incremented
* by the specified values
******************************************************************/
void Advance(Time & t, unsigned hours, unsigned minutes); 57
 /* Determine if one time is less than another time.
*
* Receive: Times t1 and t2
* Return: True if t1 < t2, false otherwise.
******************************************************************/
bool LessThan(const Time & t1, const Time & t2);

//========= Time.cpp -- implements the functions in Time.h =========

#include "Time.h"

/*** Utility functions -- might be added as basic operations later ***/

int ToMilitary(unsigned hours, unsigned minutes, char AMPM);

void ToStandard(unsigned military,

unsigned & hours, unsigned & minutes, char& AMPM);

//... Definitions of Set, Display, Advance, LessThan, ToMilitary,

// and ToStandard go here --- see the text.

58
 C++ Types

Fundamental Types Structured Types

array
Arithmetic void pointers struct
union
class
istream
ostream
Integral Floating point bool complex iostream
(reals) ifstream
ofstream
istringstream fstream
string
Characters Enumerations Integers float ostringstream vector
double stringstream deque
long double list
int stack
char queue
unsigned char short int
long int priority_queue
signed char map
unsigned
unsigned short multimap
set
unsigned long multiset
bitset
valarray
59