Notes
Outline
Structured Data Types
Unlike a simple data type which has only a single data item, a structured data type is one in which each value is a collection of component items.
String is an example of a structured data type. Individual elements are accessed by index: myString[3]
C++ has the following structured data types: struct, union, class, and arrays
Records (C++ structs)
A record is a heterogeneous structured data type (struct).
Each component of a record is called a field of the record (member), and each field is given a name called the field (member) name.
struct Syntax
StructDeclaration
struct TypeName
   {
         MemberList
    };
MemberList
    DataType MemberName ;
    DataType MemberName ;
                    .
                    .
                    .
struct Example
enum GradeType (A, B, C, D, F);
struct StudentRec
{
    string    firstName;
    string    lastName;
    float     gpa;
    int       programGrade;
    int       quizGrade;
    int       finalExam;
    GradeType courseGrade;
};
StudentRec firstStudent;
StudentRec student;
int grade;
Accessing Individual Components
To access an individual member of a struct variable, you give the name of the variable, followed by a dot (period), and then the member name. This expression is called a member selector.
      MemberSelector
          StructVariable.MemberName
Examples:
    firstStudent.gpa
    student.finalExam
Using structs
cin >> student.finalExam;
grade = student.finalExam + student.programGrade + student.quizGrade;
if (grade >= 900)
   student.courseGrade = A;
else if (grade >= 800)
   student.courseGrade = B;
else if (grade >= 700)
             .
             .
             .
Aggregate Operations on structs
An aggregate operation is one that manipulates the struct as an entire unit.
You can assign a variable of a struct type to another variable of that same type. You can pass a  struct variable to a function and return it as a function’s value.
You cannot input an entire struct variable with one statement. You cannot perfrom arithmetic or comparison operations on struct variables.
More About struct Declarations
You can declare variable names within the struct declaration.
Example:
        struct StudentRec
     {
         string firstName;
         string lastName;
            .
            .
            .
     } firstStudent, student;
One More struct Example
#include <iostream>
using namespace std;
struct player
{
int assists;
int points;
int        rebounds;
};
int triple_double (struct player);
int main()
{
player shaq, the_admiral, kobe, jason;
int shaq_td, jason_td;
One More struct Example
shaq.assists = 2;
shaq.points = 42;
shaq.rebounds = 18;
jason. assists = 12;
jason.points = 23;
jason.rebounds = 10;
shaq_td = triple_double(shaq);
cout << "shaq's triple double is " << shaq_td << endl;
jason_td = triple_double(jason);
cout << "jason's triple double is " << jason_td << endl;
}
One More struct Example
int triple_double (struct player player_name)
{
int result;
if (player_name.assists >= 10 &&
player_name.points >= 10 &&
player_name.rebounds >= 10)
result = 1;
else
    result = 0;
return result;
}
Hierarchical Records
Records whose components are themselves records are called hierarchical records.
Hierarchical Record Example
    struct DateType
    {   int month;
        int day;
        int year
    };
    struct StatisticsType
    {
        float    failRate;
        DateType lastServiced;
        int      downDays;
    };
    struct MachineRec
    {
        int            idNumber;
        string         description;
        StatisticsType history;
        DateType       purchaseDate;
        float          cost;
    };
Accessing Hierarchical Record Members
         machine.purchaseDate
     machine.purchaseDate.month
     machine.purchaseDate.year
     machine.history.lastServiced.year
Data Abstraction
The hierarchical description of the machine data is better than the flat one.
Elements are grouped together logically.
The date can be used again.
The details of the entities are pushed down to a lower level.
Abstract Data Types
To cope with complexity, the human mind engages in abstraction-the act of separating the essential qualities of an idea or object from the details of how it works or is composed.
To manage complexity, software developers regularly use two important abstraction techniques:control abstraction and data abstraction
An example of control abstraction is a function call. Ex. 4.6 + sqrt(x)
We use data abstraction when we define a new type. We concentrate initially on its logical properties and defer implementation details.
Categories of Abstract
Data Type Operations
In general, the basic operations associated with an abstract data type fall into three categories: constructors, transformers, and observers.
A constructor creates a new instance (variable) of an ADT
A transformer builds a new value of the ADT, given one or more previous values of the type.
An observer allows us to observe the state of an ADT without changing it.