Classes and Abstraction

Abstraction

• Abstraction is the separation of essential qualities from implementation details.

• Focuses on what, not how.

• Crucial for managing large, complex software projects.

Control Abstraction

• Separates logical properties of an action from its implementation.

• Example: Search(list, item, length, where, found);.

• The function call relies on the function's specification (description), not its implementation (algorithm).

Data Abstraction

• Separates logical properties of a data type from its implementation.

• Logical properties encompass possible values and required operations.

• Implementation involves how these are done in C++ and how data types are used.

Data Type

• A set of values (domain) and allowed operations on those values.

• Example: int has domain $-32768 … 32767$$$-32768 … 32767$$ and operations $, +, -, *, /,$$$, +, -, *, /, %, >>, <<$$.

Abstract Data Type (ADT)

• An ADT is a data type defined by its properties (domain and operations) independently of any specific implementation.

ADT Specification Example: Time

• TYPE Time

• DOMAIN: Each Time value is a time in hours, minutes, and seconds.

• OPERATIONS:

  • Set the time

  • Print the time

  • Increment by one second

  • Compare 2 times for equality

  • Determine if one time is “less than” another

ADT Specification Example: ComplexNumber

• TYPE ComplexNumber

• DOMAIN: Each value is an ordered pair of real numbers $(a, b)$$$(a, b)$$ representing $a + bi$$$a + bi$$

• OPERATIONS:

  • Initialize the complex number

  • Write the complex number

  • Add

  • Subtract

  • Multiply

  • Divide

  • Determine the absolute value of a complex number

ADT Implementation

• Choose a specific data representation using existing data types (built-in or programmer-defined).

• Write functions for each allowable operation.

Possible Representations of ADT Time

• 3 int variables

• 3 strings

• 3-element int array

• Example:

  • $10$$$10$$, $45$$$45$$, $27$$$27$$

  • $“10”$$$“10”$$, $“45”$$$“45”$$, $“27”$$$“27”$$

• Choice depends on time, space, and algorithms needed to implement operations.

Possible Representations of ADT ComplexNumber

• struct with 2 float members

• 2-element float array

• Example:

  • $-16.2$$$-16.2$$, $5.8$$$5.8$$

C++ Data Types

• Simple:

  • integral: char, short, int, long, bool, enum

  • floating: float, double, long double

• structured: array, struct, union, class

• address: pointer, reference

Class Time Specification

• In Time.h (specification file).

• Declares a class data type (does not allocate memory).

Class Time Specification (Public and Private Members)

• Public:

  • void Set (int hours , int mins , int secs);

  • void Increment ();

  • void Write () const;

  • bool Equal (Time otherTime) const;

  • bool LessThan (Time otherTime) const;

• Private:

  • int hrs;

  • int mins;

  • int secs;

C++ classType

• Facilitates re-use of C++ code for an ADT.

• Software using the class is called a client.

• Variables of the class type are called class objects or class instances.

• Client code uses public member functions to manipulate class objects.

Client Code Using Time

• Includes specification of the class using #include “time.h”.

• Declares objects of Time class: Time currentTime;, Time endTime;

• Calls member functions: currentTime.Set (5, 30, 0);, currentTime.Increment ();, etc.

Class Declaration

• Creates a data type and names the members of the class.

• Does not allocate memory for any variables of that type.

• Client code needs to declare class variables.

Class Members

• Two kinds: data members and function members.

• Class members are private by default.

Private vs. Public Members

• Data members are generally private.

• Function members are generally public.

• Private class members can be accessed only by class member functions (and friend functions), not by client code.

Aggregate Class Operations

• Built-in operations valid on class objects:

  • Member selection using dot (.) operator

  • Assignment to another class variable using (=)

  • Pass to a function as argument (by value or by reference)

  • Return as value of a function

• Other operations can be defined as class member functions.

Separate Specification and Implementation

• Specification file (time.h): specifies data and function members.

• Implementation file (time.cpp): implements the Time member functions.

Implementation File for Time

• Includes the specification file: #include “ time.h”.

• Uses scope resolution operator to associate functions with the class: bool Time::Equal(/* in */ Time otherTime) const

Member Selection Operator

• The member selection operator (.) selects either data members or function members.

I/O Classes

• Header files iostream and fstream declare the istream, ostream, and ifstream, ofstream I/O classes.

• cin and cout are class objects.

• get and ignore are function members: cin.get (someChar);, cin.ignore (100, ‘ ’);

• ifstream myInfile;, myInfile.open (“mydata.dat”);

Information Hiding

• Class implementation details are hidden from the client’s view.

• Public functions provide the interface between client code and class objects.

• Abstraction barrier between specification and implementation.

Selection and Resolution

• C++ programs typically use several class types.

• Different classes can have member functions with the same identifier, like Write().

• Member selection operator determines which object's member function is called: currentTime.Write(); // Class Time, numberZ.Write(); // Class ComplexNumber

• Scope resolution operator in implementation file specifies the class: void Time::Write () const { . . . }

Time Class Instance Diagrams

• Shows currentTime and endTime objects with private data (hrs, mins, secs) and public functions (Set, Increment, Write, LessThan, Equal).

Use of const with Member Functions

• When a member function does not modify the private data members, use const.

• Use const in both the function prototype (in specification file) and the heading of the function definition (in implementation file).

Example Using const with a Member Function

• void Time::Write () const

• The const keyword indicates that this member function does not modify the object's state.

Separate Compilation and Linking of Files

• Shows the process of compiling time.h, client.cpp, and time.cpp into object files and then linking them into an executable.

Avoiding Multiple Inclusion of Header Files

• Use preprocessor directives to prevent compilation errors from multiple #include statements for the same header file.

• Syntax:

#ifndef Preprocessor_Identifier
#define Preprocessor_Identifier
...
#endif

Example Using Preprocessor Directive

• #ifndef TIME_H

• #define TIME_H

• Wrap the class declaration in time.h within these directives to ensure it's included only once.

• #endif

Class Constructors

• A member function to initialize the private data members of a class object.

• Name is always the name of the class, and there is no return type.

Class Constructors (Multiple Constructors)

• A class may have several constructors with different parameter lists.

• A constructor with no parameters is the default constructor.

• A constructor is implicitly invoked when a class object is declared.

• If there are parameters, their values are listed in parentheses in the declaration.

Specification of Time Class Constructors

• Time (int initHrs, int initMins, int initSecs); (Parameterized constructor)

• Time(); (Default constructor)

Implementation of Time Default Constructor

• Time::Time ()

• Postcondition: hrs == 0 && mins == 0 && secs == 0

Parameterized Constructor

• Time::Time(int initHrs, int initMins, int initSecs)

• Precondition:

  • $0 <= initHrs <= 23$$$0 <= initHrs <= 23$$

  • $0 <= initMins <= 59$$$0 <= initMins <= 59$$

  • $0 <= initSecs <= 59$$$0 <= initSecs <= 59$$

• Postcondition:

  • hrs == initHrs && mins == initMins && secs == initSecs

Automatic Invocation of Constructors

• Time departureTime; // Default constructor invoked

• Time movieTime (19, 30, 0); // Parameterized constructor invoked