Advanced C++ for Java Programmers

Transcription

1 Module 7503a Michael Mäder Web:

2 Semester organisation Theoretical lecture with practical hands-on. Two exams (will be announced) Homework (optional, bonus for end grade) Eventually a Mini-Project 2

3 End grade 1/2 First exam 1/2 Second exam Additional bonus (maximum 1 point) of the end grade depending of the homework Example: 4.5 first exam, 5 second exam and.25 points on homework gives: ( )/ = 5 3

4 Information and Bibliography (printed at the school s printing service) A lot of information can be found on the web (e.g. Wikipedia, The C++ Programming Language, Bjarne Stroustrup, Addison Wesley (The C++ Bible!) C++ in a nutshell, Ray Lischner, O Reilly Practical C++ Programming, Steve Oualline, O Reilly... and a lot more 4

5 Semester agenda The following major topics will be discussed during the semester: Differences and similarities C++ specific stuff The standard template library (STL) Function pointers and function objects Memory management Casting Runtime Type Identification (RTTI) Code Optimization (optional) C language compatibility issues (optional) C++ idioms (optional) 5

6 Major reasons for Java to know C++ Native classes for Java are written in C++ Native code generation (better speed performance, less resource wasting) Tremendous amount of C++ programs and libraries exist Direct access to operating system. Hardware access C-style pointers still exist. Useful also for hardware and port access 6

7 Differences and Similarities

8 C++ Overview - Introduction Developed in early 1980 by Bjarne Stroustrup The main goals of its introduction was: Introduce object-orientation to classical C Be backward compatible to C C++ design decision were made to enhance performance Just a few standard library directly integrated with the language. But a lot of external libraries available (not in the scope of this course) 8

9 Contribution of other languages to Java Simula 9 Ada Sm alltalk C Pascal Eiffel Objective-C C++ Java Object- Pascal Oberon-2 Modula-2 Modula-3

10 Transformation from a C++ source code to an executable program High-level code C++ source code Compiler Assembly-language program Assembler Object code Linker Library 10 Executable program

11 Syntactical Similarities and Differences - main, argc, argv Main program function is the entry point of the application: int main (int argc, char* argv[]) Always a function outside of a class Returns 0 if okay and non-zero otherwise First argument (argv[0]) contains the name and the path of the program Example: /home/mdm3/prg arg1 arg2 This gives the following arguments: argv[0]: /home/mdm3/prg argv[1]: arg1 argv[2]: arg2 argc: 3 11

12 Syntactical Similarities and Differences - Classes in C++ (1) Data members : Member functions : Attributes Methods Class declaration: Describe the member functions and the data members of the class This is described in.h files (e.g. queue.h) Class definition: Contains the code that implements the member functions This is described in.cpp files (e.g. queue.cpp) 12

13 Syntactical Similarities and Differences - Classes in C++ (2) Class declaration Class TagName // class body }; Class body Data members Member functions 13

14 Syntactical Similarities and Differences - Classes in C++ (3) Example class IntQueue public: int size( void ); int isempty( void ); int isfull( void ); void enqueue( int elem ); int serve( void ); protected: int queuesize; int front; int rear; int array[100]; }; 14

15 Syntactical Similarities and Differences - Classes in C++ / Access levels Public member Accessible from anywhere Protected member Behaves as public to a derived class Behaves as private to the rest Private member (default access level) Only accessible by the member functions of its class 15

16 Syntactical Similarities and Differences - Classes in C++ / Class definition #include "IntQueue.h int IntQueue::size( void ) return queuesize; } int IntQueue::isEmpty( void ) return queuesize == 0; } int IntQueue::isFull( void ) return queuesize == 100; } void IntQueue::enqueue( int elem ) if(! isfull() ) rear = ( ++rear % 100 ); array[ rear ] = elem; queuesize++; } } int IntQueue::serve( void ) if(! isempty() ) Object ret = array[front]; front = ( ++front % 100 ); queuesize--; return ret; } else // exception (see later!) } 16

17 Syntactical Similarities and Differences - const member functions (1) Keyword const defines a constant variable (in Java final) The attempt to modify a const variable will create a compiler error const char blank = ; blank = x ; compilation error Class objects can also be const, thus safe and unsafe member functions exist const IntQueue queue; int emtpy = queue.isempty(); queue.enqueue (13); // safe //unsafe 17

18 Syntactical Similarities and Differences - const member functions (2) Safe member functions are indicated safe by specifying them as const class IntQueue public: int size( void ) const; int isempty( void ) const; int isfull( void ) const; void enqueue( int elem ); int serve(); //... }; The const declaration has to be repeated in the implementation int IntQueue::isEmpty( void ) const return queuesize == 0; } 18

19 Syntactical Similarities and Differences - const member functions (3) It is illegal to declare const a member function that modifies a data member. void IntQueue::enqueue( int elem ) const if(! isfull() ) rear = ( ++rear % arraysize ); array[ rear ] = elem; queuesize++; } } 19

20 Syntactical Similarities and Differences - Instantiation and object access (1) Two different instantiations exist in C++ Static instantiation (automatic allocation and freeing of memory) IntQueue queue; // executes constructor... queue.enqueue(7); } // here, the queue object is destroyed Java doesn t use the static way, it uses the dynamic allocation! 20

21 Syntactical Similarities and Differences - Instantiation and object access (2) Dynamic instantiation (explicit usage of new and delete). Java uses the same mechanism. The only exception is the automatic garbage collector, which doesn t exist in C++ IntQueue* queueptr; // creation of IntQueue pointer // allocation of memory and execution of the constructor queueptr = new IntQueue(); (*queueptr).enqueue(13); // dereferencing method queueptr->enqueue(13); // abbreviated method delete queueptr; // destructor and freeing of memory The -> operator dereference an object for function using 21

22 Syntactical Similarities and Differences - Instantiation and object access (3) No garbage collection exists in C++, for this reason, the programmer is responsible to destroy any dynamically created objects. The delete (free in Java) command will be used for this purpose. The creation and destruction of dynamic arrays looks like this: // create an array of 10 IntQueue objects IntQueue* queues = new IntQueue [10] // destruct the 10 queues delete [] queues; 22

23 Syntactical Similarities and Differences - Reference Types (1) A reference type declares a new symbol for an existing variable or object int i = 10; int& p = i; // p stands for the same adr as i int m = p; // m = 10 int* r = &p; // r is a pointer to i A reference type must always be initialized int& q; // error, not initialized In the example above p means the same memory place than i Reference type should only be used as argument or return type of functions. (They can be very confusing) 23

24 Syntactical Similarities and Differences - Reference Types (2) C++ passes arguments by value. Thus, modifications are made on local copies and the arguments remain untouched void swap (int v1, int v2)...} Using pointers is a work around void pswap (int* v1, int* v2)...} The call would be: pswap(&i, &j); Another possibility is to use the reference types void rswap (int& v1, int& v2)...} The call would be: rswap(i, j); The reference types are used in the following cases: When the function arguments have to altered in the function (like Java) When large objects have to be passed (time and space costs) 24

25 Syntactical Similarities and Differences - Reference Types (3) Reference types can also be used as return type. This avoids the creation of a copy of a huge object HugeObj addobjects( HugeObj& l, HugeObj& r) } HugeObj result;... return result; // the whole object is copied With a reference type as return type: HugeObj& addobjects( HugeObj& l, HugeObj& r) }... return result; // a reference to result is returned The object result must be a data member of the class HugeObj 25

26 New room allocation Rolex Building, room N321 Still Monday 17h55 19h30 26

27 Syntactical Similarities and Differences - Reference Types - Exercise Exercise 1-1 (page 10) 27

28 Syntactical Similarities and Differences - This pointer (1) Any object instance maintains its own copy of the class data member But only one copy of the member functions exists This presents two problems: As only one instance of a member function exists, it can t be stored inside the class object instance How are the particular data members of a class manipulated within the member function? The this pointer (similar to the this reference in Java) can solve this problem Each class member function contains a pointer of its class type 28

29 Syntactical Similarities and Differences - This pointer (2) The member function void Point::Shift(int dx, int dy) x += dx; y += dy; } Will be internally by the Compiler modified into a nonmember C function like this: void Shift Point(Point* this, int dx, int dy) } this->x += dx; this->y += dy; 29

30 Syntactical Similarities and Differences - This pointer (3) Invocation of the member function mypoint.shift(2, 3); Will be translated by the compiler to Shift Point(&myPoint, 2, 3); The programmer can also explicitly reference the this pointer bool Point::isEqual(Point& p) if (this == &p) return true; // physical eq return ((x==p.x)&&(y==p.y)); } 30

31 Syntactical Similarities and Differences Static Class Members (1) All instances of a class have access to the same variable (e.g. counters, flags, Mutex,...) For example a counter of object instances The same than class methods and class data fields in Java This global variable for its class provides two major advantages over the usage of global variables: Information hiding (declaring as private) The static member is not in the program s global name space (avoids name conflicts) 31

32 Syntactical Similarities and Differences Static Class Members (2) Definition of the single static member in a class with the keyword static in front of the data type class TempFile public: static int nrofopenedfiles(void); private: static int nroffiles; } 32

33 Syntactical Similarities and Differences Static Class Members (3) The initialization must be done outside the class definition (like a non-member variable) Normally done in the definition file (e.g. TempFile.cpp) The class scope must be used: int TempFile::nrOfFiles = 0; A member function that accesses only static members may be declared also static (see slide before) Accessing a static data member is like accessing any other data member. 33

34 Syntactical Similarities and Differences Static Class Members (4) A static member function has no this pointer A static member and/or a static member function can be accessed respectively invoked directly (even if no object of the class exists) openfiles = TempFile::nrOfOpenedFiles(); 34

35 Syntactical Similarities and Differences Inline functions (1) Inline member functions are declared and defined within its class Compiler optimization can reduce call overhead of inline functions, by calling directly the compiled code (inline expansion) The inline specifier forces the compiler to try the inline expansion Inline requests are reserved for small, frequently used functions (e.g. operator functions, getter, setter,...) Inline functions are used to replace the C-style macros (e.g. #define max(x, y) ((x > y)? x: y)) Inline functions are type-safe!!! (Not the case of C- style macros) 35

36 Syntactical Similarities and Differences Inline functions (2) Examples class X public: char* func(void) return i;}; //inline by default } is the same as: inline char* X::func(void) return i; } 36

37 Syntactical Similarities and Differences Inheritance (1) In C++ no explicit base class (as in Java the Object class) exists Any class that does not have a super class is a base class Inheritance should be used in the normal OO way The syntax: class subclass : public baseclass example next slide 37

38 Syntactical Similarities and Differences Inheritance (2) class Vehicle public: Vehicle(); Vehicle(unsigned int wt); unsigned int getweight(void) const; void setweight(unsigned int wt); private: unsigned int weight; }; class LandVehicle : public Vehicle public: LandVehicle(); LandVehicle(unsigned int wt, unsigned int sp); unsigned int getspeed(void) const; void setspeed(unsigned int sp); private: unsigned int speed; }; 38

39 Syntactical Similarities and Differences Inheritance (3) Three inheritance level for the base class exists: Public inheritance The inheritance is part of the interface Private inheritance The inheritance is not part of the interface, it is just an implementation detail Protected inheritance The inheritance is part of the interface of the derived class 39

40 Syntactical Similarities and Differences Inheritance (4) Access specifier in the base class Public inheritance Private inheritance Protected inheritance Private Private member Private member Private member Public Public member Private member Protected member Protected Protected member Private member Protected member 40

41 Syntactical Similarities and Differences Inheritance Initialization of a derived classes (1) Different possibilities to initialize a derived class exists The easy one, where the default constructor of the base class is used: LandVehicle::LandVehicle(unsigned int wt, unsigned int sp) setweight(wt); setspeed(sp); } Not very good, because first the default constructor of Vehicle is called and then the setter method setweight This can be done in one single step 41

42 Syntactical Similarities and Differences Inheritance Initialization of a derived classes (2) Not the base classe s default constructor will be used, but its customized one that already sets the weight of the vehicle. LandVehicle::LandVehicle(unsigned int wt, unsigned int sp) : Vehicle(wt), speed(sp) // nothing to do } The list of the calls right after the constructer is called member initialization list The member initialization list can contain calls to the baseclass constructors as also constructors for class members 42

43 Syntactical Similarities and Differences Multiple inheritance A C++ class can be derived from more than just one super class (not possible in Java) The derivation from multiple classes will be specified in a comma separated list: class Truck : public Engine, public Trailer... } The keyword (public, private or protected) must be repeated before each base class specification. Of course, the access levels can be intermixed! 43

44 Syntactical Similarities and Differences Polymorphism The same operation may behave differently on different classes E.g. the addition operation on an integer behaves different as on a complex number The dynamic binding or late binding decides during runtime which classes operation will be executed Virtual functions uses the dynamic binding Without using virtual functions, no dynamic binding will be performed, even if the pointers are cast to another class type! 44

45 Syntactical Similarities and Differences Polymorphism Virtual functions Virtual declared functions will cope with the previously seen problem, that a cast pointer to an object will execute function of the cast object The keyword virtual for the common methods must be used Only class member functions can be declared as virtual The redefinition of a virtual function in a derived class must match exactly the name, signature and return type of the base class instance If the redefinition doesn t match exactly, the function is not handled as virtual for the derived class 45

46 Syntactical Similarities and Differences Polymorphism Pure Virtual functions (1) Pure virtual functions are functions that aren t declared in the base class, because it makes no sense to call the function on a base class object The Java correspondence are the abstract method Any class that declares or inherits a pure virtual function is a abstract base class The creation of an object of an abstract base class will cause a compile error! A class inheriting from an abstract base class and overriding an pure virtual function will become a concrete (non-abstract) class 46

47 Syntactical Similarities and Differences Polymorphism Pure Virtual functions (2) An abstract base class declares an interface No full set of implementation is needed Similar to Java interface (interfaces doesn t exist in C++) The interface specifies the abstract operations of all derived objects A pure virtual function is declared with a =0 after the argument class Vehicle public: virtual unsigned int getspeed(void) = 0; } 47

48 Syntactical Similarities and Differences Exercises that should be checked and that should count for the bonus must: be mailed to with the Subject: [Exercisex-y] at latest on Monday after, not after 17h00 48