Exercise. Game Programming in C++ Overview. Art vs. Science in Programming. Organising your code. Organising your code

Size: px

Start display at page:

Download "Exercise. Game Programming in C++ Overview. Art vs. Science in Programming. Organising your code. Organising your code"

Cory Hill
6 years ago
Views:

1 Exercise Game Programming in C++ Arjan Egges Lecture #5: The art of programming Write a function that calculates the frequency of a given character in a string, e.g. for string arjan and character a, the function would return 2 The function should work, but try to design it in the most ugly, incomprehensible, unreadable and inefficient way you can imagine Art vs. Science in Programming After a certain level of technological skill is achieved, science and art tend to coalesce in aesthetic plasticity and form. The greater scientists are artists as well. (Albert Einstein) Alice Calaprice, The New Quotable Einstein, Princeton. Overview Organising your code File & directory structures Namespaces Comments Hungarian notation ness References Functions Organising your code Use a directory structure to group related classes: #include <iostream> #include "graphics/graphicsrenderer.h" #include "graphics/mesh.h" #include "ai/enemy.h" #include "ai/finitestatemachine.h" Organising your code Another way to group code and classes: namespaces Syntax: namespace name { // put your code here 1

2 Organising your code #ifndef CIRCLE_H_ #define CIRCLE_H_ namespace geom { class Circle { Circle(); float getsurface() const; protected: float radius_; ; #endif Circle.h Organising your code #include "Circle.h" namespace geom { Circle::Circle() { radius_ = 1.0f; float Circle::getSurface() { return 3.14 * radius_ * radius_; Circle.cpp Organising your code Comments A few tips on using namespaces: When developing a toolkit, use a single namespace for all classes Only put using namespace statements in definitions (.cpp) and not in headers (.h) Comments serve to clarify code and provide additional information to users, e.g. Provide comments for: Header files containing functions and data structures For each data structure and function (with parameters, in/out and return values) Class descriptions All constructors/methods and the destructor Description of class attributes Comments Doxygen/Javadoc method Coherent documentation throughout your code Automatic generation of documentation (HTML, PDF, LaTeX, ) Automatic extraction of class structure (dependency graphs, inheritance structures, etc) Comments You can add a brief description and a detailed description: * Brief description which ends at * this dot. Details follow here. Example: * A constructor. * A more detailed description. Test(); 2

Comments * A normal member taking two arguments * and returning an integer value. * @param[in] a an integer argument. * @param[in] s a const character reference.

* @see testme() * @param[in] c1 the first argument. * @param[out] c2 the second argument. virtual void testmetoo(char c1,char& c2) = 0; * A public variable. * Details.

3 Comments * A normal member taking two arguments * and returning an integer value. a an integer argument. s a const character reference. Test() ~Test() testmetoo() publicvar() The test results int testme(int a, const char& s); Comments * A pure virtual member. testme() c1 the first argument. c2 the second argument. virtual void testmetoo(char c1,char& c2) = 0; * A public variable. * Details. int publicvar; Hungarian notation Invented by Charles Simonyi from Microsoft Helps as a reminder of the type in the variable name Can be extended to include scope information in the variable name as well The book uses a subset of Hungarian notation Scope prefixes: m_ s_ Hungarian notation Class member variable, for example: m_hitpoints. Class static variable, for example: s_heapname. g_ Global variable, for example: g_userinfo. Type prefixes: b i f p Hungarian notation Boolean variable, for example: balive. Integer, for example: inumitems. Floating point, for example: fratio. Pointer, for example: pitem. Hungarian notation Combination of scope and type prefixes: bool m_bcanfly; static std::string* s_pname; What are disadvantages of using this notation? 3

4 const int MAX_PLAYERS = 4; MAX_PLAYERS = 2; // Compiler error! Advantage of using const over #define : allows the compiler to apply C++ type-safety variables are entered into the symbol table and are thus available in the debugger and pointers: int * pdata1 = new int(1); const int * pdata2 = new int(2); int * const pdata3 = new int(3); const int * const pdata4 = new int(4); Examples: *pdata2 = 5; // compiler error pdata2 = pdata1; *pdata3 = 5; pdata3 = pdata1; // compiler error Pointers to const objects are frequently used in functions // The Point3D object that pos points // to will not be modified. void Enemy::setPosition(const Point3D * pos); *pdata4 = 5; // compiler error pdata4 = pdata1; // compiler error class Player { void setname(const char* name); char* getname(); char* name_[128]; ; char* Player::getName() { return name_; A better way where we enforce that the returned pointer cannot be modified: const char* Player::getName() { return name_; Or even better: const char* Player::getName() const { return name_; 4

5 Defining const methods precise control over which methods update the object If you use this use it everywhere! class SomeClass { void amethod() const; void anothermethod(); ; void SomeClass::aMethod() const { this->anothermethod(); // compiler error Disadvantages of using const Link with older libraries using const wrongly Sometimes member variables do not represent the status of the object E.g. a variable maintaining some internal information, such as a counter for keeping track how often a method has been called. Solution: Use the mutable keyword class Player { void setname(const char* name); const char* getname() const; char* name_[128]; mutable int getnamecounter_; ; const char* Player::getName() const { getnamecounter _++; // OK, because mutable return name_; References References are most commonly used to pass function parameters: // setrot takes a const reference to a new // rotation matrix void Joint::setRot(const Matrix4& rot) { if (!rot.isidentity()) // a matrix is expensive to copy Matrix4 rotation; // but we can call setrot without copying it! myjoint.setrot(rotation); References References can also be used as return objects: const Matrix4& Joint::getRot() const { return rotation_; // cheap, just a ref // Watch out, this makes a copy of the matrix! Matrix4 rotation = myjoint.getrot(); // This just holds the reference. Very cheap. const Matrix4& rotation = myjoint.getrot(); References Advantages over pointers: Clearer syntax: position = entity.getposition(); As opposed to: position = *(entity->getposition()); References can never be NULL more difficult to pass an invalid reference No doubt on who is owner of object 5

6 References Are also used to avoid copies of objects: bool setactivecamera(camera c); More efficient: bool setactivecamera(const Camera& c); The const part is not necessary for avoiding the copy, but it is there to indicate we don t modify the Camera object References So are pointers obsolete?? Nooo. Sometimes pointers are still useful: When we want to transfer ownership of object When we want to change the object we point to (example: sorting) When we rely on the fact that pointers can be NULL Pointer arithmetic Functions form the basic components of programming Analytic knife (Zen and the Art of Motorcycle Maintenance by Robert Pirsig) Each function type has a certain overhead C++ offers different types of functions Normal/global functions Class static functions Non-virtual member function Virtual member functions Global/C functions: int ihitpoints = GetHitPoints(gameUnit); Cost: jumping to a different memory location (almost negligable) General rule: forget about performance overhead and use functions whenever it seems logical: Implementation in smaller sub-steps More readable code Easier to maintain code Encourages reuse (same sub-steps can be reused in other problems Class static functions: Similar to global functions, but limited to a class Class static calls are handled in a similar way as global function calls by the compiler Therefore the same performance overhead as global function calls Provides a way to group related functions under a class for better understanding of code Nonvirtual member functions Functions associated with a particular instance of a class GameUnit gameunit; int ihitpoints = gameunit.gethitpoints(); Function address is determined at link time. Type of object is known at compile time 6

7 Nonvirtual functions Implemented by having a hidden this parameter that points to the object begin called Internal representation: GameUnit gameunit; int ihitpoints = GameUnitClass gethitpoints(&gameunit); Additional performance cost: passing the extra parameter Mostly, no final difference in performance Virtual member functions Have potential to be the most expensive Occur when we invoke a method on polymorphic objects: Example (runai is a virtual member in the GameUnit class): GameUnit* pgameunit = new SomeGameUnit(); pgameunit->runai(); Virtual member functions Performance overhead for dereferencing the vtable: GameUnit* pgameunit = new SomeGameUnit(); (pgameunit->vptr[3])(pgameunit); This cost might become an issue if the function would be called for example a 1000 times per frame Only one vtable per class Can be stored anywhere in memory cache miss Virtual member functions Since each class has its own vtable, the depth of the inheritance hierarchy has no influence on performance When a virtual function is invoked directly on the object, same performance hit as normal function call: GameUnit gameunit; gameunit.runai(); But this goes through virtual function lookup: GameUnit* pgameunit = new GameUnit(); gameunit->runai(); Virtual member functions: Multiple inheritance appends vtable of parent classes Additional performance cost for offset to point to the correct section Using a large multiple inheritance tree could result in a large table Higher cost for calculating correct offsets More data cache misses class GameUnit { bool isactive() const; bool active_; ; bool GameUnit::isActive() const { return active_; if (gameunit.isactive()) 7

8 Every time we call the function IsActive(), we will have the function overhead This is okay, but the function is quite trivial We could avoid additional performance cost by making active_ if (gameunit.active_) But now the user of our class needs to know about its implementation It will get even worse if the function does a bit more than only return a member variable: bool GameUnit::isActive() { return alive_ && running_; Now we need to expose both variables and we cannot guarantee the state of our instances Suppose we then decide that isactive should be calculated as follows: (alive_ && running_) selected_; Update all our code everywhere Instead, use inline functions: class GameUnit { bool isactive() const; bool active_; ; inline bool GameUnit::isActive() const { return active_; A second alternative of writing this: class GameUnit { inline bool isactive() const { return active_; bool active_; ; The compiler replaces the function with the code in the executable: No function calling overhead, so more efficient execution Inline functions must be declared in the header, not in the cpp file! When putting inline in front of a function, there is no guarantee the compiler will actually inline it! Why not always use inlining? Executable size because of code duplication Consumes more memory Poor use of code cache lower program performance Many includes move to the.h files, resulting in longer compilation times You lose the declaration/implementation separation Avoid using inline when developing, but add inlining later when you re optimizing/finalizing your code Useful for small, frequently used methods like get-set methods 8

9 Summary Organising your code (comments, notation, ) References Next course: Design patterns 9

C++ (Non for C Programmer) (BT307) 40 Hours

C++ (Non for C Programmer) (BT307) 40 Hours Overview C++ is undoubtedly one of the most widely used programming language for implementing object-oriented systems. The C++ language is based on the popular