Lecture 5. Function Pointers

Transcription

1 Lecture 5 Complicated declarations Pointers to functions Templates Classes const member functions Constructors and destructor Allocating and deallocating memory Common pitfalls TNCG18 (C++): Lec 5 1 Function Pointers Pointers to functions Pointer contains the address of function Function name is starting address of code that defines function Function pointers can be Passed to functions Returned from functions Stored in arrays Assigned to other function pointers TNCG18 (C++): Lec 5 2 1

2 Function Pointers Declaration bool (*compare) (int, int); bool leq(int a, int b) { return a <= b; } bool geq(int a, int b) { return a >= b; } Call through function pointer compare = geq; //Dereference pointer to function to execute (*compare) (4,5); Example: multipurpose bubble sort See Fig05_25.cpp TNCG18 (C++): Lec 5 3 Complicated Declarations It is important to understand them for using library functions etc. In OpenGL you have the following functions: void glpolygonstipple(const Glubyte *mask); void glutdisplayfunc(void (*f)(void)); Whatis this?! TNCG18 (C++): Lec 5 4 2

3 Complicated Declarations int* ptr; int y, x = 5; //non constant pointer to constant data const int* ptr; //int const* ptr; ptr = &x; *ptr = 100; //ERROR!! ptr = &y; //constant pointer to nonconstant data int* const ptr = &x; ptr = &y; //ERROR!! *ptr = 100; //increment x //constant pointer to constant data const int* const ptr = &x; TNCG18 (C++): Lec 5 5 Complicated Declarations int* f; int* f(void); int (*f)(void); //pointer to a function int* (*f)(void); int a[10]; int* a[10]; //array of pointers TNCG18 (C++): Lec 5 6 3

4 Complicated Declarations int** f; //array of 10 pointers to functions int (*f[10])(void); The right-left rule: 1. Start with identifier in the innermost parentheses 2. Go right, then go left 3. Reverse direction when parenthesis is encountered TNCG18 (C++): Lec 5 7 Complicated Declarations //array of 10 pointers to functions // with no args and return int int (*f[10])(void); Could write more clear: typedef int (*funptr)(void); funptr F[10]; TNCG18 (C++): Lec 5 8 4

5 Function Templates template < typename T > // or template< class T > T maximum( T value1, T value2, T value3 ) { T max = value1; if ( value2 > max ) max = value2; if ( value3 > max ) max = value3; return max; Function calls written as usual: int max = maximum(4,3,6); } // end function template maximum TNCG18 (C++): Lec 5 9 Function Templates The compiler constructs a new function for every call and replaces T with the correct data. Called function-template specialization Standard Template Library (STL) is based on templates You can have different template parameters in functions and classes template < typename T1, T2 > T1 f(t1 a, T2 b) {...} Class templates are also possible TNCG18 (C++): Lec

6 Generic Code in C++ C++ offers several mechanisms to write generic code Pointers to functions as arguments to other functions E.g. Sorting functions that sort ascending or descending Templates TNCG18 (C++): Lec 5 11 What Are Classes? Classes See Fig06_6.6 Model objects Attributes (data members) Behaviors (member functions) Defined using keyword class Member functions also called methods Member access specifiers public: Accessible wherever object of class in scope private: Accessible only to member functions of class protected: TNCG18 (C++): Lec

7 Initializing Class Objects: Constructors Constructor function Special member function Initializes data members Same name as class Called when an object is created Several constructors Function overloading Default constructor No return type TNCG18 (C++): Lec 5 13 Declaring Objects Class name new type specifier Time sunset; // object of type Time // default constructor is called Time sunset1(5,10,12); Time arrayoftimes[ 5 ]; Time *pointertotime; Time &dinnertime = sunset; // array of Time objects // pointer to a Time object // reference to a Time object sunset1.printstandard(); pointertotime->printstandard(); (*pointertotime).printstandard(); dinnertime.printstandard(); Equivalent statements TNCG18 (C++): Lec

8 const Member Functions Member functions declared const cannot modify objects data members See Fig07_14_16 class Time { public: void printuniversal() const; void printstandard() const; private: int hour; // 0-23 (24-hour clock format) int minute; // 0-59 int second; // 0-59 }; // end class Time In C++, const objects can only be passed as arguments to member functions declared const TNCG18 (C++): Lec 5 15 Accessing Class Members Data members, member functions Immediately accessible by all member functions Referenced by name Outside class scope Can only access public data members and public functions Referenced through object name, reference to object, pointer to object TNCG18 (C++): Lec

9 Destructors Destructors Special member function Performs termination housekeeping Before system reclaims object s memory Reuse memory for new objects Same name as class Preceded with tilde (~) No arguments See Fig06_15_17 No return value Cannot be overloaded No explicit destructor Compiler creates empty destructor TNCG18 (C++): Lec 5 17 Default Memberwise Assignment Assigning objects Assignment operator (=) Can assign one object to another of same type Default: memberwise assignment Each right member assigned individually to left member This behaviour can be re-programmed Time sunset1(5,10,12); Time sunset; sunset = sunset1; TNCG18 (C++): Lec

10 Separating Interface from Implementation Header files Class definitions and function prototypes Included in each file using the class #include Time.h File extension.h See Fig06_09_11 Source-code files Member function definitions Same base name (Time.cpp) Convention TNCG18 (C++): Lec 5 19 Dynamic Memory Management Control allocation and deallocation of memory Reserves/frees memory for an object/ variable Operators new and delete Include standard header Access to standard version of new #include <new> TNCG18 (C++): Lec

11 Dynamic Memory Management new Time *timeptr; timeptr = new Time; new operator Creates object of proper size for type Time Error if no space in memory for object Calls default constructor for object Returns pointer of specified type Providing initializers double *ptr = new double( ); Time *timeptr = new Time(12,0,0); TNCG18 (C++): Lec 5 21 Dynamic Memory Management new Allocating arrays of objects Time *timesarray = new Time[10]; Default constructor called for each of the 10 Time objects Advantage: If there is not a good guess in advance how big the array should be TNCG18 (C++): Lec

12 Dynamic Memory Management new Allocating arrays of pointers to objects BigObj* *array = new BigObj*[1024]; Advantage: may save a lot of space Default constructor not called bytes array BigObj array[1024]; //1K objects k = 1 Mega TNCG18 (C++): Lec 5 23 Dynamic Memory Management new Allocating arrays of pointers to objects BigObj* *array = new BigObj*[1024]; array[0] = new BigObj; //default constructor is called array BigObj TNCG18 (C++): Lec

13 Dynamic Memory Management delete Destroy dynamically allocated object and free space delete array[0]; Operator delete Calls destructor for object Deallocates memory associated with object Memory can be reused to allocate other objects TNCG18 (C++): Lec 5 25 Dynamic Memory Management delete Deallocating arrays delete [] array; Deallocates array to which array points If pointer to array of objects 1. First calls destructor for each object in array 2. Then, deallocates memory TNCG18 (C++): Lec

14 Class Employee class Employee { public: // constructor Employee(const char *, const char *); ~Employee(); // destructor char *getfirstname() const; char *getlastname() const; private: //data members char *firstname; char *lastname; }; See Fig07_17_19 TNCG18 (C++): Lec 5 27 A constructor for Employee Employee::Employee( const char *first, const char *last){ firstname = first; lastname = last; } int main(){ char s1[10] = Anna ; char s2[10] = Pettersson ; Employee e(s1, s2); cout << e.getfirtsname() << endl; s1[0]= T ; cout << e.getfirtsname() << endl; return 0; What can be the problem? } TNCG18 (C++): Lec

15 What can be the serious problem? Employee *e; void anemployee(){ char s1[10] = Anna ; char s2[10] = Pettersson ; e = new Employee(s1, s2); } int main(){ anemployee(); cout << e->getfirstname() << endl; Employee e2( Elin, Ericsson ); } cout << e->getfirstname() << endl; return 0; TNCG18 (C++): Lec