C++lecture9

DATA ABSTRACTION: USER DEFINED TYPES AND THE CLASS

DATA TYPES A DATA TYPE IS A FORMAL DESCRIPTION OF: 1. THE DOMAIN THAT AN OBJECT OF THAT TYPE CAN HAVE. 2. THE BASIC SET OF OPERATIONS THAT CAN BE APPLIED TO VALUES OF THAT TYPE. 3. DATA REPRESENTATION.

THE FORMAL DESCRIPTION OF int AND float VALUES AND THE ALLOWABLE OPERATIONS ON SUCH DATA TYPE COME FROM MATHEMATICS. THE OPERATIONS ARE: + , - , * , AND / . THE RANGE OF VALUES CAN BE LISTED AS INT_MIN TO INT_MAX .

THE VALUES OF TYPE char ARE THE ALPHANUMERIC CHARACTERS OF THE ASCII SET. MEMBERS ARE ORDERED IN RELATION TO EACH OTHER. '0' < '1' < '2' < ... '7' < '8' < '9' AND 'a' < 'b' < 'c'< ... 'x' < 'y' < 'z'

AN OBJECT OF THE BASIC TYPES int , float , AND char CAN HOLD ONLY ONE VALUE. EACH ONE IS MADE UP OF INDIVISIBLE, OR ATOMIC ELEMENTS. int AND char SHARE A COMMON PROPERTY: THEY ARE ORDINAL TYPES. THE VALUES OF EACH TYPE CAN BE LISTED IN A SEQUENCE.

IN SOME INSTANCES, THE BASIC TYPES MAY NOT BE SUITABLE FOR DATA REPRESENTATION, OR SIMPLY NOT QUITE READABLE. C++ HAS A MECHANISM FOR ALLOWING TO CREATE NEW DATA TYPES. THAT IS, THE PROGRAMMERS DECLARE AND DEFINE NEW TYPES. DATA ABSTRACTION: SIMPLE TYPES (USER-DEFINED)

EXAMPLE: TYPE DEFINITION typedef existing_type_name new_type_name ;

A SIMULATION OF THE TYPE Logical : typedef int Logical; const Logical TRUE = 1; const Logical FALSE = 0; : Logical positive; : positive = TRUE; // initialize flag

MORE ON DATA ABSTRACTION ABSTRACT DATA TYPES PROVIDE FOR THE ABILITY TO MODEL THE DOMAIN AND OPERATIONS OF DATA WITHOUT ANY CONCERN ABOUT IMPLEMENTATION.

THE CASE OF THE "COUNTER" A COUNTER IS A SIMPLE INTEGER VARIABLE. ITS VALUE IS CHANGED AND ACCESSED DEPENDING ON SOME OTHER TASK.

COMMON OPERATIONS PERFORMED (ON THE INTEGER VARIABLE) ARE: 1. CLEAR (START AT SOME INITIAL VALUE) 2. ALTER THE VALUE TO KEEP TRACK OF TASK (INCREMENT) 3. ALTER THE VALUE TO KEEP TRACK OF TASK (DECREMENT) 4. EXAMINE OR PRINT THE CURRENT VALUE (ACCESS)

EXAMPLE: PROBLEM : GRADUATION CERTIFICATION REFERS TO EVALUATING EARNED CREDITS TO ASSURE THAT STUDENTS HAVE SATISFIED CURRICULUM REQUIREMENTS. SOME STUDENTS DO, SOME DO NOT. DEVELOP AND IMPLEMENT A SYSTEM THAT KEEPS TRACK OF THOSE STUDENTS WHO ARE GRADUATING AND THOSE THAT ARE DELAYED BASED ON NUMBER OF CREDITS EARNED.

ANALYSIS : 1. DISCUSSION (ONLY REGARDING COUNTER) THE OPERATIONS TO BE PERFORMED ON THE COUNTER ARE: INITIALIZE INCREMENT DECREMENT ACCESS

2. SPECIFICATION (ONLY REGARDING COUNTER) a) OPERATIONS void Initialize(int); void Increment(); void Decrement(); int Access_Value(); b) DATA int value;

GRAD-VALID VALIDATE GET_CREDITS PRINT RESULT LEVEL 0 LEVEL 1 3. STRUCTURE CHART

RELATIONSHIP BETWEEN DATA AND OPERATIONS: SEPARATE ENTITIES PROCESS A DATA STRUCTURES CONTROL STRUCTURES PROCESS D PROCESS C PROCESS B

ALTERNATIVE REPRESENTATION THE CLASS , A SET OF OBJECTS, ALLOWS FOR THE REPRESENTATION OF DATA AND OPERATIONS INTO A COHESIVE UNIT.

RELATIONSHIP BETWEEN DATA AND OPERATIONS: A COHERENT UNIT CONTROL STRUCTURES AND DATA STRUCTURES PROCESS A PROCESS D PROCESS C PROCESS B DATA

THE C++ CLASS A MECHANISM TO MODEL OBJECTS WITH MULTIPLE ATTRIBUTES. THE C++ CLASS ALLOWS FOR THE DEFINITION A NEW TYPE OF DATA ACCORDING TO THE NEEDS OF THE PROBLEM, AND TO DEFINE OPERATIONS (METHODS) TO ACT UPON THE TYPE (ABSTRACT DATA TYPING).

INFORMATION HIDING THE ENCAPSULATION OF IMPLEMENTATION DETAILS. PRIVATE CODE AND DATA CANNOT BE ACCESSED DIRECTLY.

CLASS SYNTAX class <class_name> { public: <public declaration list> private: <private declaration list> };

class <class_name> { public: <public data structures> // optional <constructors> // optional <function prototypes> // optional private: // optional <private data structures> // optional <function prototypes> // optional };

EXAMPLE 1 // class declaration section class Date { private: int month; //a data member int day; // a data member int year; // a data member public: Date( int = 11, int = 16, int = 2001 ); // the constructor void setdate(int, int, int); // a member function void showdate(); // a member function } ;

SYNTAX OF DEFINING MEMBER FUNCTIONS <return_type> <class_name> :: <function_name> ( <parameter_list> ) { <function member body> }

EXAMPLE 1 // class implementation section Date::Date( int mm, int dd, int yyyy) { month = mm; day = dd; year = yyyy; } void Date:: setdate(int mm, int dd, int yyyy) { month = mm; day = dd; year = yyyy; return ; }

void Date::showdate() { cout<< “ The date is “; cout<< setfill ( ‘0’) << setw(2)<< month << ‘/ ‘ << setw(2)<< day << ‘/ ‘ << setw(2)<< year % 100 ; // extract last //two year digits cout<< ednl ; return ; }

Class Scope and Accessing Class Members A class data members and function members belong to that class scope. Nonmember functions are defined as file scope. Within class scope members are accessible by using their name Outside class scope, class members are referenced through one of the handles on an object – an object name, a reference to an object or pointer to an object. Variable defined in member function has function scope. You can hide data member in a function by using same name.

Once the class has been defined, it can be used as a type in object, array and pointer definitions. For example class Date can be used in the following main function as follows

int main () { Date a, b, c(4, 1, 1998) // declare three objects – //initialize one of them b.setdate(12, 25, 2002);//assign values to b’s data members a.Showdate( ); // display object a’s values b.Showdate( ); // display object b’s values c.Showdate( ); // display object c’s values return 0 ; } /*output The date is 07/04/01 The date is 12/25/02 The date is 04/01/98 */

IMPLEMENTATION: THE Counter CLASS // File: Counter.h #include <limits.h> // contains definitions of // INT_MAX and INT_MIN class Counter { public: // member functions void Initialize(int init_value); // initialize counter void Increment(); // increment counter void Decrement(); // decrement counter int Access_Value(); // return current counter // value private: // data members int value; };

void Counter::Initialize(int init_value) // initialize counter { value = init_value; } // Initialize() void Counter::Increment() // increment counter { if (value < INT_MAX) value++; else cerr << "Counter overflow. Increment ignored." << endl; } // Increment()

void Counter::Decrement() // decrement counter { if (value > INT_MIN) value--; else cerr << "Counter underflow. Decrement ignored." << endl; } // Decrement() int Counter::Access_Value() // return current counter value { return value; } // Access_Value()

#include <iostream.h> #include "Counter.h" void main() { // Minimum credits for graduation const int GRAD_LEVEL = 130; // local objects of class Counter Counter c_graduated; Counter c_delayed; // local data int class_size, number_of_credits; int i; // get the graduating class size cout << "Enter the class size: "; cin >> class_size; IMPLEMENTATION (USING THE Counter CLASS)

// initialize counter values c_graduated.Initialize(0); c_delayed.Initialize(class_size); // use of Increment() and Decrement() for (i = 0; i < class_size; i++) { cout << "Please enter the number of validated credits: "; cin >> number_of_credits; if (number_of_credits >= GRAD_LEVEL) { c_graduated.Increment(); c_delayed.Decrement(); } } // print results using Access_value() cout << "The number of students graduating this semester: " << c_graduated.Access_Value() << endl; cout << "The number of students delayed this semester: " << c_delayed.Access_Value() << endl; return; }

See example on page 405 and 406

Constructors A constructor function is any function that has the same name as it s class. Constructors can be over loaded Constructor has no return type If no constructor is written compiler will provide default constructor

Default Constructor Any constructor that does not require any parameters when it is called. This can be because no parameters are declared All parameters have been given default values. For example Date(int=7, int =4, int = 2001 )

Destructor The name of the destructor for a class is the tilde(~) character followed by the name of the class. There can be only one destructor Destructor take no parameter and it has no return value Destructor is called when a class object is destroyed. A default destructor is provided if not written by programmer.

ANOTHER EXAMPLE: PROBLEM : USING FLOATING POINT NOTATION TO REPRESENT FRACTIONS MAY PRODUCE APPROXIMATE RESULTS. FOR EXAMPLE, THE RATIONAL NUMBER 1/3 IS 0.33333. REGARDLESS OF THE NUMBER OF ACCURATE DIGITS, IT WOULD BE IMPOSSIBLE TO PRECISELY REPRESENT SUCH A NUMBER. DESIGN, DEVELOP AND IMPLEMENT A SYSTEM TO REPRESENT FRACTIONS ACCURATELY. AS AN EXAMPLE, WE WILL IMPLEMENT THE ADDITION OPERATION ONLY.

ANALYSIS : 1. DISCUSSION THE OPERATIONS TO BE PERFORMED ON THE Fraction CLASS ARE: CONSTRUCT AND INITIALIZE A NEW FRACTION OBJECT DISPLAY A FRACTION GET A FRACTION ADD TWO FRACTIONS (RESULTING IN THIRD FRACTION) CONVERT TO FLOAT POINT NOTATION

2. CLASS SPECIFICATION A) PUBLIC CONSTRUCT: Fraction(int n, int d = 1); Fraction(); void Get(); void Show(); double Evaluate(); B) PRIVATE int numerator; int denominator; C) FRIEND friend Fraction operator+ (Fraction f1, Fraction f2);

NEW CONCEPTS FRIEND FUNCTIONS, OPERATOR OVERLOADING, AND CONSTRUCTORS

class <class_name> { friend <function prototype> ; // optional public: <public data structures> // optional <constructors> // optional <function prototypes> // optional private: // optional <data structures> // optional <function prototypes> // optional };

class Fraction { // operator overload, so we can do fractional arithmetic // using a familiar operator, the "+" sign friend Fraction operator+ (Fraction f1, Fraction f2); public: : private: : }; FRIEND FUNCTIONS AND OPERATOR OVERLOADING

class Fraction { : public: Fraction(int n, int d = 1); // constructor Fraction(); // another constructor : private: : }; CONSTRUCTORS

// File: Fraction.h // The class declaration for fractions is included in this // header file. We represent a fraction using a pair of integers: // the numerator (top part) and denominator (bottom part). // This class definition includes more than the rational // numbers, since the number infinity is permitted (a fraction // with a zero denominator--except 0/0)

class Fraction { // operator overload, so we can do fractional arithmetic // using a familiar operator , the "+" sign friend Fraction operator+ (Fraction f1, Fraction f2); public: Fraction(int n, int d = 1); // constructor // Set numerator = n, denominator = d // if no second argument, default to 1 // another constructor: Fraction(); // Set numerator = 0, denominator = 1 void Get(); // Get a fraction from keyboard void Show(); // Display a fraction on screen double Evaluate(); // Return the decimal value of a fraction private: int numerator; // top part int denominator; // bottom part };

// File: Fraction.cpp // The class definition for fractions #include <iostream.h> #include "Fraction.h" Fraction operator+ (Fraction f1, Fraction f2) // Override of operator "+" for fraction addition { Fraction r; // the return value of f1 + f2 // compute numerator r.numerator = (f1.numerator * f2.denominator) + (f2.numerator * f1.denominator); // compute denominator r.denominator = f1.denominator * f2.denominator; return r; // return the result }

Fraction::Fraction(int n, int d) // A Fraction constructor which allows the numerator and // denominator to be specified { numerator = n; denominator = d; }

Fraction::Fraction() // Another constructor. If no arguments specified, default to 0/1 { numerator = 0; denominator = 1; }

void Fraction::Get() // Get a fraction from standard input, in the form // "numerator/denominator" { char div_sign; // used to consume the '/' character during input cin >> numerator >> div_sign >> denominator; }

void Fraction::Show() // Display a fraction, in the form "numerator/denominator" { cout << numerator << '/' << denominator; }

double Fraction::Evaluate() // Calculates and returns the decimal value of a fraction { double n = numerator; // convert numerator to float double d = denominator; // convert denominator to float return (n / d); // return float representation }

// File: TestFraction.cpp // Test the Fraction class #include <iostream.h> // for output #include "Fraction.h" // for Fraction declarations void main() { // Fraction constructors Fraction f1(3, 2), f2(4), f3, f4; // Display the fractions cout << endl << "The fraction f1 is "; f1.Show(); cout << endl << "The fraction f2 is "; f2.Show(); cout << endl << "The fraction f3 is "; f3.Show(); // Get and display a fraction cout << endl << "Enter a fraction of your own: "; f3.Get(); cout << endl << "You entered "; f3.Show();

// Add two Fractions using the overloaded operator f4 = f1 + f3; // Display the fractions and result cout << endl << endl << "The sum of "; f1.Show(); cout << " and "; f3.Show(); cout << " is "; f4.Show(); // Find and display the floating-point value of the Fraction cout << endl << "The value of this fraction is " << f4.Evaluate() << endl; }

C++lecture9

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to C++lecture9 (20)

More from FALLEE31188 (20)

Recently uploaded (20)

C++lecture9

Editor's Notes