G52PGP. Lecture OO2 Object Oriented programming in C

Transcription

1 G52PGP Lecture OO2 Object Oriented programming in C

2 Last OO lecture Brief comments about the Object Oriented Paradigm Reminder of basic C code Including structs and pointers A simple one-function C program Functional decomposition Collecting data together into a struct Passing a pointer to the structto functions to use 2

3 Questions from the decomposition Where is the data going to be stored? It was in local variables for that function only Do we move it into globals? Or pass pointers to the local variables into each function call? Do we need to have multiple copies? (e.g. single program runs two games simultaneously?) Maintenance How hard is it to change something? What if I want a random number of zombies? What if I want to add new types of map items e.g. teleporters, treasure to pick up, etc What if I want multiple types of zombies? Maybe with some random behaviour? 3

4 This Lecture An object oriented approach in C We will try this from a C point of view, to see what is happening, and what features actually do We need to cheat slightly since C doesn t support overloaded functions (i.e. compiling as C++) We will use structfor our objects Group data together into coherent objects Create functions which work on those objects Let ONLY those functions access the data in the objects Pass a pointer to the object to work on into the function

5 Benefits and penalties of this approach Benefits: More control over the access to the data The internal data format can be changed Modifications/maintenance much easier As long as the functions don t change then nobody should even realise it Can add checks, logging, etcon the data access Penalties More code to write Partly because C doesn t have the object oriented support natively would be less code in C++ or Java Java and C++ have better support to reduce the amount of code that we have to write so don t worry

6 Data in Zombies struct Data int zombie_x[max_zombies ]; int zombie_y[max_zombies ]; char zombie_old[max_zombies]; int player_x = 0; int player_y = 0; char player_old = 0; int pit_x, pit_y; char* display[max_rows]; ;

7 Data in Zombies struct Data int zombie_x[max_zombies ]; int zombie_y[max_zombies ]; char zombie_old[max_zombies]; int player_x = 0; int player_y = 0; char player_old = 0; int pit_x, pit_y; char* display[max_rows]; ; x, y, content x, y, content x, y

8 Zombies Game as interacting objects Display (Board/Map) 2D array of contents Position X Y struct Data Mover zombie[max_zombies]; Mover player; Position pit; Display d; ; Mover X Y Old content

9 Decomposition and warning Decomposition basically means splitting up the problem into smaller parts Here we have decomposed the data which is needed into smaller clumps of data And we will define some functions to work on that data There are other ways to split this up There are probably better ways to handle the display data (the strings) Remember this when you come back to revise this is not the ideal object model for this problem 9

10 Zombies Game as interacting objects Display (Board/Map) 2D array of contents Position X Y struct Data Mover zombie[max_zombies]; Mover player; Position pit; Display d; ; Mover X Y Old content

11 Example : simulating position objects struct Position int x; int y; ; Create the structure to group the data Create distinct set of functions to use it Simplest functions are: Getters - Accessors Setters Mutators Use these functions NEVER access the data directly from another function // Getters get values int getpositionx( Position* p ) // Getter return p->x; int getpositiony( Position* p ) // Getter return p->y; // Setter sets values void setposition( Position* p, int newx, int newy ) // Setter p->x = newx; p->y = newy; 11

12 Other Position Functions struct Position ; int x; int y; int getpositionx( Position* p ) return p->x; int getpositiony( Position* p ) return p->y; void setposition( Position* p, int newx, int newy ) p->x = newx; p->y = newy; void modifyposition( Position* p, int xoffset, int yoffset ) p->x += xoffset; p->y += yoffset; void randomizepositiondifferentto( Position* pnew, Position* pcheck ) pnew->x = rand() % MAX_COLS; pnew->y = rand() % MAX_ROWS; if ( (pnew->x == pcheck->x) && (pnew->y == pcheck->y) ) randomizepositiondifferentto( pnew, pcheck );

13 The mover object could contain a position Position X Y Mover X Y Old content Mover X Y Old content Position struct Mover // Figure which can move // Embed Position object inside, which has x & y Position p; // Old value at location char cvalue; ;

14 Simple mover functions struct Mover // Figure which can move Position p; // Embed Position object inside, which has x & y char cvalue; // Old value at location ; // Simplest wrapper - just avoids ever getting the value directly int getstoredcontent( Mover* pm ) return pm->cvalue; // Simplest wrapper - just avoids ever setting the value directly void setstoredcontent( Mover* pm, char value ) pm->cvalue = value;

15 Other functions on Mover // Get the position from the embedded position object int getpositionx( Mover* pm ) int getpositiony( Mover* pm ) Position* getposition( Mover* pm ) // Questionable // Set the position: give x and y positions or offset void setposition( Mover* pm, int newx, int newy ) void modifyposition( Mover* pm, int xoffset, int yoffset ) // Randomly determine the original position, in various ways void randomizeposition( Mover* pm ) // Totally random void randomizezombieposition( Mover* pm ) // Random in outside edges // Different to a specific position or another mover void randomizepositiondifferentto( Mover* pset, Position* pcheck ) void randomizepositiondifferentto( Mover* pset, Mover* pcheck ) int isdead( Mover* pm ) // Is the mover dead (x and y are -1 if so) void setdead( Mover* pm ) // Record that mover is dead // This function uses the existing get and modify position functions void movetowardsothermover( Mover* pthis, Mover* target ) 15

16 Finally, Display struct Display char* data[max_rows]; // renamed to data ; // Basic functions create/draw/destroy the strings void createdisplaydata( Display* pd ) // Initialise it void freedisplaydata( Display* pd ) // Free it void drawdisplay( Display* pd ) // Draw the display // Retrieve the value at a location int getdisplayvalue( Display* pd, int x, int y ) // Set value given x and y coordinates or a position void setdisplayvalue( Display* pd, int x, int y, int value ) void setdisplayvalue( Display* pd, Position* p, int value ) 16

17 And some functions to change the map struct Display char* data[max_rows]; // renamed to data ; // Set value given a position object void setdisplayvalueforposition( Display* pd, Position* pos, int value ) // Set value for Mover s position to stored or fixed value void setdisplayvaluetomoverstored( Display* pd, Mover* m ) void setdisplayvalueatmoverposition( Display* pd, Mover* m, char cvalue ) // Retrieve the value from map, and optionally store in a mover void storedisplayvalueinmover( Display* pd, Mover* m ) char retrievevalueatmoverposition( Display* pd, Mover* m ) 17

18 The main function is conceptually easier Old code: for ( i = 0 ; i < MAX_ZOMBIES ; i++ ) if ( pdata->zombie_y[i] >= 0 ) New code: pdata->display[pdata->zombie_y[i]] [pdata->zombie_x[i]] = ZOMBIE; for ( i = 0 ; i < MAX_ZOMBIES ; i++ ) if ( isdead( zombie[i] ) == 0 ) setdisplayvalueatmoverposition( display, zombie[i], ZOMBIE ); We can see more easily what it is actually doing 18

19 The calling function is conceptually easier Old code: for ( i = 0 ; i < MAX_ZOMBIES ; i++ ) if ( pdata->zombie_y[i] >= 0 ) pdata->display[pdata->zombie_y[i]] [pdata->zombie_x[i]] = ZOMBIE; Note: I cheated actually these are New code: pointers to the for ( i = 0 ; i < MAX_ZOMBIES ; i++ ) data but I simplified it for if ( isdead( zombie[i] ) == 0 ) this slide setdisplayvalueatmoverposition( display, zombie[i], ZOMBIE ); We can see more easily what it is actually doing 19

20 Decomposition Here we used the data to identify possible objects because we already had the data This is usually a BAD way to create an object oriented program it will lead to a poor design Later we will see other ways to identify objects Similar to ER diagrams in database theory too In software engineering module you will see some more detail about OO design We have now divided the work but not functional decomposition by object-based decomposition The objects collaborate together to solve tasks Each of the individual functions is quite simple The functions on the objects work together to solve tasks As a developer, you can think of one object at a time

21 Simplifying matters This got us to the fake functions sample Now we will go further 21

22 Example was a lot of work struct Position int x; int y; ; Each of these functions has the same first parameter We had to type Position* p each time And we had to specify p-> to use the data // Getters get values int getpositionx( Position* p ) return p->x; int getpositiony( Position* p ) return p->y; // Setter sets values void setposition( Position* p, int newx, int newy ) p->x = newx; p->y = newy; 22

23 We could name the parameter consistently struct Position int x; int y; ; Since the parameter is the same, and always refers to the current object, we could give it a consistent name, e.g. this // Getters get values int getpositionx( Position* this ) return this->x; int getpositiony( Position* this ) return this->y; // Setter sets values void setposition( Position* this, int newx, int newy ) this->x = newx; this->y = newy; 23

24 First parameter can be implicit struct Position int x; int y; <insert functions here> Declare functions within the class compiler knows that they need to have an object to act on and makes a hiddenfirst parameter, called this // Getters get values int getpositionx(position* this) return this->x; int getpositiony(position* this) return this->y; // Setter sets values void setposition(position* this, int newx, int newy ) this->x = newx; this->y = newy; 24

25 The this-> can be implicit too struct Position int x; int y; <insert functions here> Compiler also knows that you will often access member data or member functions The compiler will check whether adding a this-> works before checking for globals with that name // Getters get values int getpositionx() return this->x; int getpositiony() return this-> y; // Setter sets values void setposition( int newx, int newy ) this->x = newx; this->y = newy; 25

26 struct Position int x; int y; Final code for a Position int getpositionx() return x; int getpositiony() return y; void setposition( int newx, int newy ) x = newx; y = newy; Note: in C++ we would actually do something slightly different to this, but we are heading for Java so I did it this way Attend the C++ Programming module to learn more Final version has a lot less code but does the same thing as the original version 26

27 Calling a function struct Position int x; // etc for y int getpositionx() return x; ; int main( int argc, char* argv[] ) struct Position pos; pos.setposition(3, 4); printf("position is %d, %d\n", pos.getpositionx(), pos.getpositiony()); printf("position is %d, %d\n", pos.x, pos.y ); When we call the function we no longer specify an object pointer as a first parameter. Instead we specify the object to act on before a. The same way as we would access member data jaa@shadowfax2 ~ $ g++ struct_test.cpp jaa@shadowfax2 ~ $./a.exe Position is 3, 4 Position is 3, 4 27

28 Class, object and struct In OO design and programming, you define a set of classes A class is a type of object A class specifies the data that each object of that class has Defining a class does not create any objects of that class An object is an instance of the class The lump of data of the format specified by the class i.e. each object actually resides somewhere in memory It will have a set of functions which act upon it 28

29 Public and private data (1) Nothing so far has stopped things outside of our class from accessing its data We can do so by making the data private struct Position private: int x; int y; public: int getpositionx() return x; int getpositiony() return y; ; void setposition(int newx, int newy) x = newx; y = newy; 29

30 Public and private data (2) If we do so, then the compiler will not let us access the private data struct Position private: int x; int y; public: int getpositionx() int getpositiony() int main( int argc, char* argv[] ) struct Position pos; pos.setposition(3, 4); printf("position is %d, %d\n", pos.getpositionx(), pos.getpositiony()); ; void setposition( int newx, int newy) printf("position is %d, %d\n", pos.x, pos.y ); return 0; 30

31 Public and private data (2) If we do so, then the compiler will not let us access the private data struct Position private: pos.x, pos.y); int^ x; int y; public: int getpositionx() int getpositiony() ; struct_test_private.cpp:10:6: error: int Position::x is private intx; ^ struct_test_private.cpp:38:7: error: within this context int main( int argc, char* argv[] ) struct Position pos; pos.setposition(3, 4); printf("position is %d, %d\n", pos.getpositionx(), pos.getpositiony()); struct_test_private.cpp:11:6: error: int Position::y is private inty; ^ void setposition( struct_test_private.cpp:38:14: int newx, int newy) error: within this context pos.x, pos.y); printf("position is %d, %d\n", pos.x, pos.y ); return 0; 31

32 Static members If we add data (variables) or methods (functions) to a class (or struct), it adds an implicit parameter (this), to say which object the function to acting on We may want to make a function a member (so that it can access private functions or data) but not give it the hidden this pointer This is basically a global function with access to the private data and functions Just make this a static member E.g. static int compare(position* pos1, Position* pos2) // Compare somehow? return (pos1.x - pos2.x) + (pos1.y - pos2.y); 32

33 Classes, instances and static Classes are outlines for objects Specify the data stored Specify the functions which can act on the data Objects are lumps of data You usually associate functions and data with instances (instance methods, instance data) You can associate them with the class Rather than each instance Make them static Static methods have no this pointer no instance Static data has one copy only, not one per instance I.e. shared by all instances (like global data) 33

34 Why all of this detail? When students get to the C++ programming module in year 2, I have seen a lot of confusion over what classes and objects are Also a lot of confusion over what static means A lot of erroneous use of static in Java by students Eclipse will often suggest making functions static to fix compilation errors A lot of procedural programming paradigm code that looks object oriented but isn t I am determined that you will understand You need to understand what static means You need to understand what a member function really is Question: If I add a member function to a class/struct, do the objects grow? What if I add member data? 34

35 Summary Member functions/methods are just functions with an extra (hidden) pointer to denote which object they are currently working on obj.foo() means apply function foo() to object obj (i.e. the hidden this pointer points at obj) You can protect data (or functions) so that ONLY members can access them You can make something a member without implicitly adding the hidden thispointed (e.g. if it does not act on a specific object) Make it static It can still access private data if you give it a pointer to an object somehow You can make data static too we will see this later 35

36 Next Lecture An introduction to Java Creating our first Hello World Java program Text output Some Java Classes Simple Graphical User Interfaces Our second, graphical, Hello World program 36