Lecture 8: Object-Oriented Programming (OOP) 1
Introduction to C++ 2
Overview Additional features compared to C: Object-oriented programming (OOP) Generic programming (template) Many other small changes Small changes: Conventional source files with.cpp extension main() function can be declared with void return type: void main() { } Use // to comment until end of line area = PI*r*r; // PI = 3.14 Built-in bool type and false, true boolean literals: bool b1 = true, b2 = false; Variables and constants in C++ can be declared anywhere in functions (not limited to function beginning only), even in for loops New function-like syntax for type casting: int(5.32) enum, struct, union keywords become optional in variable declaration 3
Some more significant features Reference types: are pointers by nature int a = 5; int& b = a; b = 10; // a = 10 int& foo(int& x) { x = 2; return x; } int y = 1; foo(y); // y = 2 foo(y) = 3; // y = 3 Namespace namespace ABC { int x; int setx(int y) { x = y; } } ABC::setX(20); int z = ABC::x; 4 using namespace ABC; setx(40);
Some more significant features (cont.) 5 Dynamic memory allocation Allocation: new and new[] operators int* a = new int; float* b = new float(5.23f); long* c = new long[5]; Deallocation: delete and delete[] operators delete a; delete[] c; Attn: do not mix malloc()/free() and new/delete: Memory allocated by malloc() must be deallocated by free() Memory allocated by new must be deallocated by delete Function overload (functions with same name but different parameters): int sum(int a, int b) {...} int sum(int a, int b, int c) {...} double sum(double a, double b) {...} double sum(double a, double b, double c) {...} Exception handling try... catch: self-study
The first C++ program Example: #include <iostream> using namespace std; void main() { } int n; cout << "Enter n: "; cin >> n; cout << "n = " << n << endl; Input/output with C++: Using iostream library cout << used for output to stdout (console by default) cin >> used for input from stdin (keyboard by default) Objects of C++ standard library defined in a namespace named std. If using is not used, one must use std::cout, std::cin, std::endl instead 6
Classes and objects 7
Introduction From real world Objects are things, facts, entities, which are characterized by properties and can realize certain operations. Ex: Each student is an object characterized by: name, age, department, class, year, and can realizes: study, doing exercises, going to class, doing tests, Each cellphone is an object characterized by: SIM number, model, size, and can realizes: making call, texting, answering to calls, denying calls, Classes are description of properties and operations of each type of objects Simpler consideration: student are objects while the notion of student is a class, similarly for cellphones and the notion of cellphone 8
Introduction (cont.) to programming: Class is a data type extended from structure type (struct). Apart from fields that correspond to object properties, methods which are similar to functions are added to realize operations Object is a variable declared with type of the defined class From structural programming: function-centered struct Student { char name[20]; int year; void go_to_class(student& s, int room) {... } void do_test(student& s) {... } Student s = {... go_to_class(s, 103); do_test(s); 9
Introduction (cont.) to object-oriented programming: struct Student { char name[20]; int year; void go_to_class(int room) {... } void do_test() {... } Student s = {... s.go_to_class(103); s.do_test(); Functions become methods of class and can access directly to properties (member variables) of called object Objects (variables) become subject of called methods (functions) instead of being passed as parameters objects play a central role in programming 10
Scope of members public properties and methods are accessible from outside of object, private ones are limited to internal uses struct Student { public: char name[20]; void go_to_class(int room) {... } private: int year; void do_test() {... } strcpy(s.name, "Nguyen Hung Long"); // OK s.go_to_class(103); // OK s.year = 2010; // error s.do_test(); // error 11
class and struct In C++, to avoid confusion with traditional structure types, use class keyword to declare classes: class Student {... class and struct types differ only in default member scopes: public for struct and private for class struct A { int a; // public class B { int b; // private Very often, member variables are defined as private, and are accessed via member methods hide internal data, better encapsulation 12
Class example #include <iostream> class Circle { private: double r; public: void setr(double rr) { r = rr; } double area() { return 3.14*r*r; } double perimeter() { return 3.14*2.*r; } void main() { } 13 Circle c; c.setr(1.23); std::cout << "Area: " << c.area() << std::endl << "Perimeter: " << c.perimeter() << std::endl;
Constructors Are initialization methods for objects. They do not return values, and invoked automatically every times an object is created. Possible to define many with different parameters, compiler knows which one to call based on given parameters. If none defined, a default one is generated. class Circle { public: Circle() { r = 0.; } // default constructor with no parameter) Circle(double rr) { r = rr; }... Circle c1, c2(), c3[3]; // constructor 1 Circle c4(1.23); // constructor 2 c1 = Circle; // error c1 = Circle(); // constructor 1 c1 = Circle(2.33); // constructor 2 14 Circle* c5 = new Circle; // constructor 1 Circle* c6 = new Circle(); // constructor 1 Circle* c7 = new Circle(3.22); // constructor 2 Circle* c8 = new Circle[3]; // constructor 1
Copy constructors Used in creation of new objects from existing ones of the same class. Two syntaxes for invoking copy constructors: class Circle {... Circle(const Circle& c) { r = c.r; } 15 Circle c1(2.5); Circle c2 = c1, c3(c1); c2 = c1; // do not use copy constructor // use copy constructor // assignment, not copy constructor Also used in creation of temporary objects for function calls: void func1(circle c) {... } void func2(const Circle& c) {... } func1(c1); // create temp. obj. c by copying from c1 with CSC func2(c1); // no obj. created, CSC is not invoked should use const Circle& c for function parameter instead of Circle& c for better performance If no copy constructor defined, compiler generates a default one which copies all member variables from original object to the new object
Cast constructors Used in creation of new objects from existing objects of different classes. Two syntaxes for invoking cast constructors: class Ellipse {... Ellipse(const Circle& c) { rx = ry = c.r; } Ellipse e1(c1), e2 = c2; // use cast constructor: Circle -> Ellipse e1 = c1; // create a temp. object by implicit cast: Circle -> Ellipse // then invoke assignment: Ellipse -> Ellipse Also used in creation of temporary objects for type casting: void func3(const Ellipse& e) {... } func3(c1); // implicit use of cast constructor cout << ((Ellipse)c1).area(); // explicit use of cast constructor Possible to add explicit keyword in declaration of cast constructor to avoid being used in implicit casts Review Circle class: class Circle {... Circle(double rr) {r = rr; } // is cast constructor: int -> Circle 16
Initialization lists There might be an initialization list following a constructor s signature for member variables that need to be initialized class Person { private: string name; int age; public: Person(const char* n): name(n) {... } Person(const char* n, int a): name(n), age(a) {...} //... Above constructors can be interpreted as Person(const char* n) { name = n; //... } Person(const char* n, int a) { name = n; age = a; //... } Must be used for constant and reference member variables, and any member variable of class that does not have default constructor 17
Destructors 18 Destructor: method to clean objects before being removed from memory. It doesn t return value, and is called implicitly every time an object is destroyed. Do not use malloc()/free() to create or delete C++ objects At most one destructor for each class class String { private: char* str; public: String() { str = NULL; } String(const char* s) { str = new char[strlen(s)+1]; strcpy(str, s); } ~String() { if (str) delete str; }... String* abc() { String s1, s2("hello!"), s3[3]; String *s4 = new String("xyz"), *s5 = new String[3]; } String *s6 = new String("abc"); delete s4; // destroy 1 object delete[] s5; // destroy 3 objs, don t use: delete s5 return s6; // destroy s1, s2, s3[3] but s6 is still there
Separating declaration and definition of methods string.h class String { private: char* str; public: String(); String(const char* s); ~String(); void set(const char* s); const char* get(); 19 string.cpp String::String() { str = NULL; } String::String(const char* s) { str = NULL; set(s); } String::~String() { if (str) delete str; } void String::set(const char* s) { } if (str) delete str; if (!s) { str = NULL; return; } str = new char[strlen(s)+1]; strcpy(str, s); const char* String::get() { return str; }
Friend functions and classes If a function or class is defined as friend of some class, than it has access to private member variables and methods of that class class Circle { private: double r; public:... friend void printcircle(circle c); friend class Ellipse; void printcircle(circle c) { cout << "Radius: " << c.r; } class Ellipse { private: double rx, ry; public: void convert(circle c) { rx = ry = c.r; } 20
this pointer Is pointer accessible only within the non-static member functions of objects, points to the object for which the member function being called class Buffer; void do_smth(buffer* buf); 21 class Buffer { private: char* b; int n; public: Buffer(int n) { this->n = n; this->b = new char[n]; } ~Buffer() { delete this->b; } void some_method() { do_smth(this); } Buffer buf(4096); buf.some_method(); Texts in red are optional (implicit), in blue are mandatory
Static variables and methods of classes Static member variables are ones that are unique for all objects of same classes (even when no object exists) Static methods are ones that make access only to static member variables class C { public: static int count; C() { count++; } ~C() { count--; } static int getcount() { return count; }... int C::count = 0; C c1, c2, c3[10], *c4 = new C(), *c5 = new C[20]; delete c4; cout << "Number of C objects: " << C::getCount() << endl; // cout << C::count << endl; // cout << c1.count << endl; // cout << c2.getcount() << endl; It s possible to access static members via class name and scope operator ::, or via objects as normal members of that class this pointer is not defined in static methods 22
Constant methods In a method declared as constant, all member variables are constant. Consequences: Impossible to assign or change member variables in constant methods Impossible to call non-constant methods from constant ones Within a constant method, only constant member methods of that object are accessible One would rather declare all methods that does not change member variables as constant class Circle { Circle c1;... const Circle c2(2.333); void setr(double r) { this->r = r; } double getr() const { return r; } c1.setr(1.22); // OK double area() const { return PI*r*r; } c2.setr(1.22); // error void cf(double r) const { area(); // OK c1.area(); // OK setr(r); // error c2.area(); // OK } this->r = r; // error cout << c1.getr() // OK << c2.getr(); // OK 23
Problems 1. Write a class (String) to encapsulate string-of-characters type char* with its typical methods 2. Write a class (File) to encapsulate FILE* type with its typical methods 3. Write a class (LList) to manipulate linked lists on the basis of the library written in C 4. Write a class (Fraction) to manipulate fractions with its typical methods 5. Complete two class Circle and Ellipse with learnt notions in this lesson: private variable, constructor, copy constructor, cast constructor, destructor, static variable to count number of instances, friend class, const method, 6. Write two class Complex and Vector with necessary methods to work with complex numbers and 3D vectors 24