1. CS-212 Intro to C++

2. Abstract Data Type Abstraction of a real world object as a mathematical entity Implementation independent model of the entity Emphasis on “what” not “how” Information Hiding to lower level of complexity Preconditions and Postconditions

3. Pre and Postconditions Preconditions: the current state of the object – ex. The object exists and has a nonzero value Postconditions: the new state of the object after the function has been performed – ex. The object still exists and has increased in value by a factor of ten are described for every operation belonging to the object

4. C++ Class An implementation of an ADT A user defined “type” Encapsulation of Data and Function – Data and its manipulators must always be kept together

5. Class Consists of : – an interface definition (fn.h header file) Data definition Definition of user interface – an implementation (fn.cpp code file) code for user interface code for helper functions – Could both be in same file but that would defeat the purpose of information hiding

6. Class Interface Definition class statement class name private: section – data content of the class – statements ahead of “public” are private – private functions are for use of the class not the class user protected: section (for base classes only) – data content of the base class (more later...) public: section – prototype statements for member functions – publishes the user interface to the class

7. Using a class Must first instantiate (make an instance of) an object of type class (ex. throttle fuel_control) Tell the object what you want it to do by using the “.” operator (dot operator). – fuel_control.shut_off() (note: specify the object and the action you want performed) – if the object returns a value assign it current = fuel_control.flow();

8. Class Constructors Assign initial values to an object Never returns a value Same name as the class Guaranteed to be called (automatic) upon instantiation of an object of type class

9. Default Constructor If no constructor is found – a default constructor, that does no initialization is used when the object is defined (only reserves the storage defined in the private section)

10. Object Initialization a single constructor may be used that assigns values to all private variables The constructor can be overloaded to provide flexibility to the user – each overload must have unique signature Good idea to always provide a default constructor that assigns some value to all private variables

11. Destructors Automatically run when an object of type class goes out of scope use to clean up after the object (return dynamically allocated storage to the storage management system Same name as the class, but preceded by a ~ no overloading allowed never returns a value not needed for statically allocated storage

12. Member Functions Also known as “setters” and getters” provide the class’ behavior you should be a “setter” function and a getter” function for each piece of private data (also known as “state data”)

13. Time class definition class Time { public: Time ( ) ; /* default constructor */ Time ( unsigned H, unsigned M, char AorP ) ; Time ( unsigned mil) ; Time (const Time & oTime ); /* copy constructor */ void SetHour(unsigned H ) ; void SetMinute ( unsigned M) ; void Setam_pm) (char C); void SetMiltime(); unsigned GetHour(); unsigned GetMinute(); unsigned Getam_pm (); unsigned GetMiltime() void Display ( ostream & out) ; private: unsigned hours, minutes ; char am_pm ; unsigned miltime ; }

14. Time class implementation Time::Time() // Constructor for the Time class { // initialize time to midnight hours = 0 ; minutes = 0; am_pm = “A”; miltime = 0; } Time::Time ( unsigned H, unsigned M, char AorP ) ; { hours = H ; minutes = M am_pm = AorP; if (am_pm ==“P”) miltime = ((hours+12)*100)+minutes; else miltime = hours*100 + minutes; }

15. Time class implementation Time:: Time ( unsigned mil) { hours = mil / 100 if (hours > 12) { hours = hours - 12; am_pm = “P”; } else am_pm = “A”; minutes = mil % 100; miltime = mil; }

16. Time Class Copy Constructor Time::Time(const Time & oTime) { hours = oTime.hours; min = oTime.min; am_pm = oTime.am_pm; miltime = oHours.miltime; }

17. Inline Member Functions If a member function is simple; define it inline in the class definition (header file) (provide the function body {.....} inline) Compiler recompiles the inline code each time it is called and places the code inline (like a C macro) – faster code – uses more storage Functions may also be “inlined” by using the Inline keyword

18. namespaces using namespace std; The concept of namespaces was added to C++ in the last release of the specification namespaces allow you to assign portions of your program to different namspaces, variable names are local so they may be reused with in a program as long as the uses are in different namespaces the namespace “std” is a little special – you don’t have to specify the “.h” for all standard #includes – #include