1. 1 CMSC 202 More C++ Classes

2. 2 Announcements Project 1 due midnight Sunday 2/25/01 Quiz #2 this week Exam 1 Wednesday/Thursday Project 2 out Monday March 5 th

3. 3 const Use “const” (constant) whenever possible Supports the concept of “least privilege” Objects may be const Member functions may be const Parameters may be const

4. 4 const Objects We’ve already seen const float PI = 3.14; that creates a float that cannot be changed We can also create const objects const Time noon(12, 0, 0); –noon is not modifiable

5. 5 const member functions Not all member functions modify the object –Accessors –Others later And so should be declared ‘const’ int GetHour ( void ) const; The compiler doesn’t “know” that GetHour( ) doesn’t modify the Time object

6. 6 (non-)const objects and (non-)const member functions Rules of engagement: –const member functions may be invoked for const and non-const objects –non-const member functions can only be invoked for non-const objects –you cannot invoke a non-const member function on a const object Constructors and Destructors may not be const

7. 7 Modified Time class Time { public: Time (int h = 0, int m = 0, int s = 0 ); void InitTime (int h, int m, int s); void PrintMilitary ( void ) const; void PrintStd ( void ) const; void Increment ( void ); …..

8. 8 Modified Time (cont’d) // mutators void SetHour (int h); void SetMinute (int m); void SetSecond (int s); // accessors – should be const int GetHour (void) const; int GetMinute (void) const; int GetSecond (void) const;

9. 9 Modified Time (cont’d) private: int hour; int minute; int second; };

10. 10 int main ( ) { Time t1 (2, 4, 7); const Time noon (12); cout << “Initial Military Time for t1 is :” ; t1.PrintMilitary ( );// okay cout << endl; cout << “Noon in Military Time:” noon.PrintMilitary ( ); // okay cout << endl; cout << “Increment Noon:” ; noon.Increment ( ); // compiler error cout << endl; }

11. 11 Non-member functions should have const reference parameters wherever possible Rules of engagement: –Non-const objects may be passed to const and non-const arguments –Const objects may only be passed to const arguments Bottom line – you can’t pass a const object to a non-const argument

12. 12 Non-member PrintTime void PrintTime (Time& t) { cout << t.GetHour( ) << “:”; cout << t.GetMinute( ) << “:”; cout << t.GetSecond( ); }

13. 13 Calling PrintTime void PrintTime (Time& t); Callable using t1 – PrintTime ( t1 ); Not callable with noon – PrintTime (noon); Why the difference?

14. 14 A better PrintTime Since PrintTime( ) doesn’t modify the Time object passed to it, the argument should be const void PrintTime (const Time& t) Doing so doesn’t change the code, but now does allow noon to use the function PrintTime (noon);

15. 15 A subtlety What happens if ‘noon’ is passed to the new PrintTime ( ) function, but the accessors are not const?

16. 16 Composition Sometimes objects are used as members of other objects. For example, an AlarmClock class may include a Time object. This is known as “composition” or “aggregation”. Member objects are constructed automatically A common form of code reuse.

17. 17 AlarmClock class AlarmClock { public: AlarmClock ( ); void SetAlarm (int h, int m, int s);... private:... void ring( ) const; Time currentTime; const Time alarmTime; }

18. 18 “this” and that Every object has access to it’s own address through a pointer called this. The this is implicitly used to reference both data members and member functions of an object… it can also be used explicitly. This is passed implicitly as the first argument of every (non-static) member function

19. 19 A “this” example // should have error checking void Time::SetMinute (int m) { this->minute = m; } More valuable later

20. 20 Dynamic Memory Allocation In C we used malloc int *intp; intp = (int *)malloc (sizeof(int) ); In C++ we use new int *intp; intp = new int; or intp = new int (7);

21. 21 Allocating Dynamic Arrays Again, in C we used malloc: int *ip2; int *ip2 = malloc (50 * sizeof(int)); In C++ we use new and the size int *ip2 = new int[10];

22. 22 Freeing Dynamic Memory In C we used free free (intp);// for a single int free (ip2);// or an array In C++ we use delete delete intp;// for a single int delete [ ] ip2;// for an array

23. 23 A simple class that uses dynamic memory Class Array { public: Array (int size = 100); void putElement (int x); int getElement (void);.... private: int *theArray; }

24. 24 Array Constructor Allocate the memory in the constructor Array::Array (int size) { theArray = new int [size]; }

25. 25 The Array Destructor Free the memory in the destructor Array::~Array ( ) { delete [ ] theArray; }

26. 26 Good Programming Practices Use const wherever possible Declare member functions that do not change the object as const Avoid friends Use member initialization lists Allocate dynamic memory only in the constructor Delete dynamic memory only in the destructor