C++

Structured Data and Classes

Combining Data into Structures

• Structure: C++ construct that allows multiple variables to be grouped together

• Structure Declaration Format: struct structure name{type1 field1;type2 field2; …

typen fieldn;};

Example struct Declaration

struct Student

{

int studentID;

string name;

short year;

double gpa;

};

structure tag

structure members

Notice the required

;

4

struct examples• Example:

struct StudentInfo{int Id;int age;char Gender;double CGA; };

• Example:struct StudentGrade{char Name[15];char Course[9];int Lab[5];int Homework[3];int Exam[2];};

The “StudentGrade” structure has 5 members of

different array types.

The “StudentInfo” structure has 4 members

of different types.

5

struct examples• Example:

struct BankAccount{char Name[15];int AcountNo[10];double balance;Date Birthday;

};

• Example:struct StudentRecord{

char Name[15];int Id;char Dept[5];char Gender;

};

The “StudentRecord” structure has 4

members.

The “BankAcount” structure has simple, array and structure

types as members.

struct Declaration Notes

• struct names commonly begin with an uppercase letter

• Multiple fields of same type can be in a comma-separated list string name,

address;

Defining Structure Variables

• struct declaration does not allocate memory or create variables

• To define variables, use structure tag as type nameStudent s1; studentID

name

year

gpa

s1

Example: structuresstruct date

{

int month;

int day;

int year;

};

struct date today, purchaseDate;

today.year = 2004;

today.month = 10;

today.day = 5;

Defines type struct date, with 3 fields of type int

The names of the fields are local in the context

of the structure.

A struct declaration defines a type: if not followed by a

list of variables it reserves no storage; it merely

describes a template or shape of a structure.

Defines 3 variables of

type struct date

Accesses fields of a variable of

type struct date

A member of a particular structure is referred to

in an expression by a construction of the

form structurename.member

9

Structure definitionStructure definition

• To define a structure for student’s To define a structure for student’s informationinformation

typedef struct {

char [30] name;

int age;

} student;

Student s1, s2;Student s1, s2;

Structure usingStructure using

• When we use the structure data asWhen we use the structure data as

S1.age = 21;S1.age = 21;

S2.age = 20;S2.age = 20;

Strcpy(s1.name, “mohamed”);Strcpy(s1.name, “mohamed”);

Strcpy(s2.name, “ahmed”);Strcpy(s2.name, “ahmed”);

Accessing Structure Members

• Use the dot (.) operator to refer to members of struct variables

getline(cin, s1.name);

cin >> s1.studentID;

s1.gpa = 3.75;

• Member variables can be used in any manner appropriate for their data type

Displaying struct Members

• To display the contents of a struct variable, you must display each field separately, using the dot operator

Wrong: cout << s1; // won’t work!Correct: cout << s1.studentID << endl; cout << s1.name << endl; cout << s1.year << endl; cout << s1.gpa;

Initializing a Structure

• Cannot initialize members in the structure declaration, because no memory has been allocated yet

struct Student // Illegal { // initialization int studentID = 1145; string name = "Alex"; short year = 1; float gpa = 2.95; };

Example• Write a program which accepts from the user via

the keyboards, and the following data items:• it_number – integer value,• name – string, up to 20 characters,• amount – integer value.• Your program will store this data for 3 persons

and display each record is proceeded by the record number.

15

Comparing struct Variables

• Cannot compare struct variables directly:

if (stu1 == stu2) // won’t work

• Instead, must compare on a member basis:

if (stu1.studentID == stu2.studentID)

Initializing a Structure (continued)

• Structure members are initialized at the time a structure variable is created

• Can initialize a structure variable’s members with either– an initialization list

– a constructor

Using an Initialization List

• An initialization list is an ordered set of values, separated by commas and contained in { }, that provides initial values for a set of data members

{12, 6, 3} // initialization list // with 3 values

More on Initialization Lists

• Order of list elements matters: First value initializes first data member, second value initializes second data member, etc.

• Elements of an initialization list can be constants, variables, or expressions

{12, W, L/W + 1} // initialization list // with 3 items

Initialization List Example

Structure Declaration Structure Variable

struct Dimensions{ int length, width, height;};

Dimensions box = {12,6,3};

box

length 12

width 6

height 3

Partial Initialization

• Can initialize just some members, but cannot skip over members

Dimensions box1 = {12,6}; //OKDimensions box2 = {12,,3}; //illegal

Problems with Initialization List

• Can’t omit a value for a member without omitting values for all following members

• Does not work on most modern compilers if the structure contains any string objects – Will, however, work with C-string members

Examples

//Create a box with all dimensions given Dimensions box4(12, 6, 3);

//Create a box using default value 1 for //height Dimensions box5(12, 6);

//Create a box using all default values Dimensions box6;

Omit () when no arguments

are used

Example

• Write a car struct that has the following fields: YearModel (int), Make (string), and Speed (int).

• The program has function assign_data ( ) accelerate ( ) which add 5 to the speed each time it is called, break () which subtract 5 from speed each time it is called, and display () to print out the car’s information.

Nested StructuresA structure can have another structure as a member.

struct PersonInfo { string name, address, city; }; struct Student { int studentID; PersonInfo pData; short year; double gpa; };

Members of Nested Structures

• Use the dot operator multiple times to dereference fields of nested structures

Student s5;

s5.pData.name = "Joanne";

s5.pData.city = "Tulsa";

Example

• Create a structTime that contains data members, hour, minute, second to store the time value, provide a function that sets hour, minute, second to zero, provide three function for converting time to ( 24 hour ) and another one for converting time to ( 12 hour ) and a function that sets the time to a certain value specified by three parameters

Arrays of Structures• Structures can be defined in arrays

• Structures can be used in place of parallel arrays

Student stuList[20];

• Individual structures accessible using subscript notation

• Fields within structures accessible using dot notation:

cout << stuList[5].studentID;

Structures as Function Arguments

• May pass members of struct variables to functions computeGPA(s1.gpa);

• May pass entire struct variables to functions showData(s5);

• Can use reference parameter if function needs to modify contents of structure variable

Example

Coffee shop needs a program to computerize its inventory. The data will be Coffee name, price, and amount in stock, sell by year. The function on coffee are: prepare to enter stock, Display coffee data, change price, add stock (add new batch), sell coffee, remove old stock (check sell by year).

Notes on Passing Structures• Using a value parameter for structure can

slow down a program and waste space

• Using a reference parameter speeds up program, but allows the function to modify data in the structure

• To save space and time, while protecting structure data that should not be changed, use a const reference parameter

void showData(const Student &s) // header

Returning a Structure from a Function

• Function can return a structStudent getStuData(); // prototype

s1 = getStuData(); // call

• Function must define a local structure – for internal use – to use with return statement

Returning a Structure Example

Student getStuData() { Student s; // local variable cin >> s.studentID; cin.ignore(); getline(cin, s.pData.name); getline(cin, s.pData.address); getline(cin, s.pData.city); cin >> s.year; cin >> s.gpa; return s; }

Example

• Design a struct named BankAccount with data: balance, number of deposits this month, number of withdrawals, annual interest rate, and monthly service charges. The program has functions: Deposit (amount) {add amount to balance and increment number of deposit by one}, Withdraw (amount) {subtract amount from balance and increment number of withdrawals by one}, CalcInterest() { update balance by amount = balance * (annual interest rate /12)}, and MonthlyPocess() {subtract the monthly service charge from balance, set number of deposit, number of withdrawals and monthly service charges to zero}.

Pointers to Structures

• A structure variable has an address

• Pointers to structures are variables that can hold the address of a structure:

Student * stuPtr, stu1;

• Use the & operator to assign an address:

stuPtr = & stu1;

• A structure pointer can be a function parameter

Accessing Structure Members via Pointer Variables

• Use () to dereference the pointer variable, not the field within the structure:

cout << (*stuPtr).studentID;

• You can use the structure pointer operator ( -> ), a.k.a arrow operator to eliminate use of(*).

cout << stuPtr -> studentID;

Pointers to Structures• You may take the address of a structure variable and create

variables that are pointers to structures.

Circle *cirPtr; // cirPtr is a pointer to a CircleCirPtr = &piePlate;

*cirPtr.radius = 10; // incorrect way to access Radius because the dot operator // has higher precedence than the indirection operator

(*cirPtr).radius = 10; //correct access to Radius cirPtr -> radius = 10;

// structure pointer operator ( -> ), easier notation for // dereferencing structure pointers

Example

• Write a complete program to– Define a person struct with members: ID, name,

address, and telephone number. The functions are change_data( ), get_data( ), and display_data( ).

– Declare record table with size N and provide the user to fill the table with data.

– Allow the user to enter certain ID for the Main function to display the corresponding person's name, address, and telephone number.

Linked List

Unions

• Similar to a struct, but– all members share a single memory location (which saves space)– only 1 member of the union can be used at a time

• Declared using key word union• Otherwise the same as struct• Variables defined and accessed like struct variables

Example union Declaration

union WageInfo{

double hourlyRate; float annualSalary;};

union tag

Notice the required

;

union members

Anonymous Union

• A union without a tag:union { ... };

• With no tag you cannot create additional union variables of this type later

• Allocates memory at declaration time

• Refer to members directly without dot operator

Enumerated Data Types

• An enumerated data type is a programmer-defined data type.

It consists of values known as enumerators, which represent integer constants.

Enumerated Data Types

• Example:

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY };

• The identifiers MONDAY, TUESDAY, WEDNESDAY, THURSDAY, and FRIDAY, which are listed inside the braces, are enumerators. They represent the values that belong to the Day data type. The enumerators are named constants.

Enumerated Data Types

• Once you have created an enumerated data type in your program, you can define variables of that type. Example:

Day workDay;

• This statement defines workDay as a variable of the Day type.

Enumerated Data Types

• We may assign any of the enumerators MONDAY, TUESDAY, WEDNESDAY, THURSDAY, or FRIDAY to a variable of the Day type.

• Example:

workDay = WEDNESDAY;

Enumerated Data Types

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY };

In memory...

MONDAY = 0TUESDAY = 1WEDNESDAY = 2THURSDAY = 3FRIDAY = 4

Enumerated Data Types• Using the Day declaration, the following

code...

cout << MONDAY << " " << WEDNESDAY << " “ << FRIDAY << endl;

...will produce this output:

0 2 4

Assigning an Enumerator to an int Variable

• You CAN assign an enumerator to an int variable. For example:

int x;x = THURSDAY;

• This code assigns 3 to x.

Enumerated Data Types• Program 11-13 shows enumerators used to

control a loop:

// Get the sales for each day.

for (index = MONDAY; index <= FRIDAY; index++){ cout << "Enter the sales for day " << index << ": "; cin >> sales[index];}

// Would not work if index was an enumerated type

Using an enum Variable to Step through an Array's Elements

• Because enumerators are stored in memory as integers, you can use them as array subscripts.

For example:

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY };

const int NUM_DAYS = 5;

double sales[NUM_DAYS];

sales[MONDAY] = 1525.00; sales[TUESDAY] = 1896.50; sales[WEDNESDAY] = 1975.63; sales[THURSDAY] = 1678.33; sales[FRIDAY] = 1498.52;

STRUCT, TYPEDEF, ENUM & UNION You cannot use the typedef specifier inside a

function definition. When declaring a local-scope identifier by the same

name as a typedef, or when declaring a member of a structure or union in the same scope or in an inner scope, the type specifier must be specified.

For example,

typedef float TestType; int main(void) { ...  } // function scope (local)int MyFunct(int){      // same name with typedef, it is OK      int TestType;}

www.tenouk.com, © 57/93

STRUCT, TYPEDEF, ENUM & UNION Names for structure types are often defined

with typedef to create shorter and simpler type name.

For example, the following statements,

typedef  struct Card MyCard;typedef unsigned short USHORT;

Defines the new type name MyCard as a synonym for type struct Card and USHORT as a synonym for type unsigned short.

Programmers usually use typedef to define a structure (also union, enum and class) type so a structure tag is not required.

For example, the following definition.

typedef struct{      char  *face;      char  *suit;} MyCard; 62/93

Creating Header File and File Re-inclusion Issue

It is a normal practice to separate structure, function, constants, macros, types and similar definitions and declarations in a separate header file(s).

Then, those definitions can be included in main() using the include directive (#include).

It is for reusability and packaging and to be shared between several source files.

Include files are also useful for incorporating declarations of external variables and complex data types.

You need to define and name the types only once in an include file created for that purpose.

The #include directive tells the preprocessor to treat the contents of a specified file as if those contents had appeared in the source program at the point where the directive appears.

www.tenouk.com, © 54/93

The syntax is one of the following,

1. #include "path-spec"2. #include <path-spec>

Both syntax forms cause replacement of that directive by the entire contents of the specified include file.

The difference between the two forms is the order in which the preprocessor searches for header files when the path is incompletely specified.

Preprocessor searches for header files when the path is incompletely specified.

www.tenouk.com, © 42/93

STRUCT, TYPEDEF, ENUM & UNION

Step: Firstly, add new header file to the existing project.

www.tenouk.com, © 45/93

STRUCT, TYPEDEF, ENUM & UNION

Step: Put the meaningful header file name.

www.tenouk.com, © 46/93

Abstract Data Types

• A programmer-created data type that specifies– legal values that can be stored– operations that can be done on the values

• The user of an abstract data type does not need to know any implementation details (e.g., how the data is stored or how the operations on it are carried out)

Object-Oriented Programming

• Procedural programming focuses on the process/actions that occur in a program

• Object-Oriented programming is based on the data and the functions that operate on it. Objects are instances of Abstract Data Types, or ADTs.

Limitations of Procedural Programming

• Use of global data may allow data corruption

• Programs are often based on complex function hierarchies – difficult to understand and maintain– difficult to modify and extend– easy to break