System Programming. Practical Session 9. C++ classes

Transcription

1 System Programming Practical Session 9 C++ classes

2 C++ parameter passing void incval(int n) { //By value n++; void incpoint(int *p) { //By pointer *p = 5; p = 0; void incref(int &n) { //By Reference cout << "incref: n = " << n << endl; cout << "incref: &n = " << &n << endl; n++; Printout main: &x = 0xbfab547c main: x2 = 2 main: &x2 = 0xbfab547c x = 2 *q = 5 incref: n = 5 incref: &n = 0xbfab547c x = 6 int main(int argc, char *argv[]) { int x = 2; int &x2 = x; cout << "main: &x = " << &x << endl; //main: &x = 0xbfab547c cout << "main: x2 = " << x2 << endl; //main: x2 = 2 cout << "main: &x2 = " << &x2 << endl; //main: &x2 = 0xbfab547c incval(x); cout << "x = " << x <<endl; //x = 2 (and not 3!) int *q = &x; incpoint(q); cout << "*q = " << *q <<endl; //*q = 5 incref(x); cout << "x = " << x << endl; //x = 6

3 C++ STL examples - Vector void clean_odd(std::vector<int> &vec) { std::vector<int>::iterator iter = vec.begin(); while (iter!= vec.end()) { if (*iter % 2 == 0) { iter++; else { iter = vec.erase(iter); int main(int argc, char *argv[]) { std::vector<int> vec; vec.push_back(0); vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5); Printout clean_odd(vec); for (std::vector<int>::iterator iter = vec.begin(); iter!= vec.end(); ++iter){ std::cout << *iter << std::endl; return 0;

4 C++ STL examples - Map int main(int argc, char *argv[]) { std::map<std::string,int> stringcounts; std::string str; std::vector<string> vec; vec.push_back("abc"); vec.push_back("123"); vec.push_back("qaz"); vec.push_back("789"); vec.push_back("abc"); vec.push_back("123"); Printout word: 123, count: 2 word: 789, count: 1 word: abc, count: 2 word: qaz, count: 1 std::vector<string>::iterator veciter = vec.begin(); while (veciter!= vec.end()) { std::map<std::string,int>::iterator found = stringcounts.find(*veciter); if (found!= stringcounts.end()) { found->second++; else { stringcounts.insert(std::make_pair(*veciter, 1)); veciter++; std::map<std::string,int>::iterator iter; for( iter = stringcounts.begin(); iter!= stringcounts.end(); ++iter) { std::cout << "word: " << iter->first << ", count: " << iter->second << std::endl; return 0;

5 C++ STL examples - Priority Queue class Cow { private: int _id; public: Cow(int id) : _id(id) { ; int getid() const { return _id; // A comparator is a class that implements the operator() // It is passed as a parameter to the priority queue // and used to perform the comparisons among items in the queue. class CowComparator { public: bool operator()(const Cow &x, const Cow &y) { // return true if x < y, false otherwise return x.getid() < y.getid(); ; int main(int argc, char *argv[]) { typedef std::priority_queue<cow, std::vector<cow>, CowComparator> PrioQueue; PrioQueue queue; queue.push(cow(0)); queue.push(cow(3)); queue.push(cow(1)); queue.push(cow(2)); Printout while (!queue.empty()) { std::cout << queue.top().getid() << std::endl; queue.pop();

6 Outline Basic concepts Classes that hold pointers Destructor Copy constructor Operator=

7 C++ simple class example // THE DECLARATION FILE OF THE CLASS POINT (Point.h) class Point { public: Point(); Point(double xval, double yval); void move(double dx, double dy); double getx() const; //const functions do not change the state of an object double gety() const; private: double _x; double _y; ; // semicolon at the end of the class declaration - const functions do not change the state of an object - const functions cannot modify const data. - when const functions return references or pointers to members of the class, they must also be const. - const methods can only access const methods.

8 C++ simple class example // THE IMPLEMENTATION FILE OF CLASS POINT (Point.cpp) #include "Point.h" Point::Point():_x(0), _y(0){ //The :: operator separates class name and method name Point::Point(double xval, double yval):_x(xval),_y(yval){ void Point::move(double dx, double dy) { _x = _x + dx; _y = _y + dy; double Point::getX() const { //const functions do not change the state of an object return _x; double Point::getY() const { return _y;

9 C++ simple class example Use example //Once a variable declared as const, one can only use methods declared const on that variable #include <iostream> #include point.h int main( ){ Point p(0,0); //Point p; p.move(10,15); std::cout << p.getx() << std::endl; std::cout << p.gety() << std::endl; const Point p2(20,12); // p2.move(1,1); compilation error since move is not declared const std::cout << p2.getx() << std::endl; std::cout << p2.gety() << std::endl;

10 Member Initialization List // THE DECLARATION class Circle{ ; public: Circle(); Circle(double centerx, double centery, double radius); private: Point _center; double _radius; // THE IMPLEMENTATION Circle::Circle(): _center(0,0), _radius(1) { //default constructor Circle::Circle(double centerx, double centery, double radius): _center(centerx, centery), _radius(radius) {

11 Member Initialization List Example: Circle::Circle(): _center(0,0), _radius(1) { Rules The initial value can be any expression. The order the initialization happens is according to the order the member variables are declared. The member initialization list is executed before the body of the constructor. Not initializing a member (class object) via the initialization list means implicitly calling its default constructor Const members of a class can only be initialized via member initialization list.

12 Syntax: class Derived : public Base { ; Inheritance #include point.h #include color.h // suppose that we have defined class Color class Pixel : public Point{ //instead of extends in Java Color _color; ; Pixel::Pixel(Point point, Color color) : Point(point), _color(color) { // example of a derived constructor calling the base constructor // Syntax: Derived::Derived(.) : Base(.) { // instead of super in Java

13 -<Operator Shortcut for accessing members of an object pointed by a pointer. ptr->member is a shortcut for (*ptr).member class Point{... int main( ){ Point *p1=new Point(0,0); Point p2(0,0); p1->getx(); (*p1).getx(); p2.getx(); (&p2)->getx();

14 Objects In C++, object variables hold values, not object references. When one object is assigned to another, a copy of the actual values is made. When modifying an object in a function, you must remember to use call by reference. Two object variables cannot jointly access one object. If you need this effect in C++, then you need to use pointers/references An object variable can only hold values of a particular type. If you want a variable to hold objects from different subclasses, you need to use pointers. If you want a variable point to either null or to an actual object, then you need to use pointers in C++.

15 The "this" Pointer Note that, as in Java, this is a pointer to the active object. So for example, when: L1 = L2 is executed, L1's member function operator= is called, so this is a pointer to L1. We also make use of this for the returned value in the operator=. the type to be returned is List& so we dereference this, a.k.a return *this. We would like to establish a way to distinguish between parameters and class variables. This can be done by the "this" pointer. It used as a pointer to the class object instance by the member functions. this pointer stores the address of the object instance, to enable pointer access of the object. this pointers are not accessible for static member functions. this pointers are not modifiable.

16 Classes that hold pointers A class that has a pointer data member should include the following member functions: 1. A virtual destructor 2. A copy constructor 3. operator= (assignment)

17 Linked List Example Link data_ next_ List head_ data_ next_ data_ next_

18 Link class Link { private: Link* next_; std::string data_; public: Link(const std::string& data, Link* link); Link(const Link& alink); //copy constructor virtual ~Link(); // destructor void setnext(link* link); Link* getnext() const; const std::string& getdata() const; ;

19 Link Link::Link(const std::string& data, Link* link) : data_(data) { setnext(link); void Link::setNext(Link* link) { next_=link; Link* Link::getNext() const { return next_; const std::string& Link::getData() const { return data_; Link::~Link() { Link::Link(const Link& alink) { Data_= alink.getdata(); Next_= 0; // destructor // copy constructor

20 List class List { private: Link* head_; Link* copy() const; void clear(); public: List(); const Link* gethead() const; void insertdata(const std::string& data); void removefirst(); ; List(const List& alist); virtual ~List(); List& operator=(const List &L);

21 List::List() : head_(0) { List //Constructor, Builds an empty list const Link* List::getHead() const{ return head_; void List::insertData(const std::string& data){ head_ = new Link(data, head_); Before (insertdata(...) ): data_ next_ data_ next_ 0 Current head_ After (insertdata(...) ): data_ next_ data_ next_ data_ next_ 0 Current head_ Old head_

22 List List::List() : head_(0) { //Constructor, Builds an empty list const Link* List::getHead() const{ return head_; void List::insertData(const std::string& data){ head_ = new Link(data, head_); void List::removeFirst(){ //removes the current head if (0!= head_) { Link* tmp = head_; head_ = head_->getnext(); delete tmp; Before deleting tmp (removefirst): data_ next_ data_ next_ data_ next_ 0 tmp head_->getnext()

23 List List::List() : head_(0) { //Constructor, Builds an empty list const Link* List::getHead() const{ return head_; void List::insertData(const std::string& data){ head_ = new Link(data, head_); void List::removeFirst(){ //removes the current head if (0!= head_) { Link* tmp = head_; head_ = head_->getnext(); delete tmp; List::~List() { clear(); //Destructor: "deep delete" void List::clear(){ while (0!= head_) { removefirst(); //Clear all content (delete all links)

24 Link* List::copy() const { //deep copy of this list (allocates links) if (0 == gethead()) { return 0; else { Link *head = new Link(*getHead()); //call copy constructor of Link Link *next = head; for (Link *origptr = gethead()->getnext(); 0!= origptr; origptr = origptr->getnext()) { next->setnext(new Link(*origPtr)); next = next->getnext(); return head; List to copy (this instance of list): List - continued data_ next_ data_ next_ 0 head_ Copied List: data_ next_ 0 head

25 Link* List::copy() const { //deep copy of this list (allocates links) if (0 == gethead()) { return 0; else { Link *head = new Link(*getHead()); //call copy constructor of Link Link *next = head; for (Link *origptr = gethead()->getnext(); 0!= origptr; origptr = origptr->getnext()) { next->setnext(new Link(*origPtr)); next = next->getnext(); return head; //origptr points to node in original list that is not yet copied List to copy (this instance of list): List - continued data_ next_ data_ next_ data_ next_ 0 gethead() Temp origptr Copied List: data_ next_ 0 head/next

26 Link* List::copy() const { //deep copy of this list (allocates links) if (0 == gethead()) { return 0; else { Link *head = new Link(*getHead()); //call copy constructor of Link Link *next = head; for (Link *origptr = gethead()->getnext(); 0!= origptr; origptr = origptr->getnext()) { next->setnext(new Link(*origPtr));//create a new link for next next = next->getnext(); return head; //origptr points to node in original list that is not yet copied List to copy (this instance of list): List - continued data_ next_ data_ next_ data_ next_ 0 gethead() Temp origptr Copied List: data_ next_ data_ next_ 0 head/next next->setnext(...))

27 Link* List::copy() const { //deep copy of this list (allocates links) if (0 == gethead()) { return 0; else { Link *head = new Link(*getHead()); //call copy constructor of Link Link *next = head; for (Link *origptr = gethead()->getnext(); 0!= origptr; origptr = origptr->getnext()) { next->setnext(new Link(*origPtr));//create a new link for next next = next->getnext(); return head; //origptr points to node in original list that is not yet copied List to copy (this instance of list): List - continued data_ next_ data_ next_ data_ next_ 0 gethead() Temp origptr Copied List: data_ next_ data_ next_ 0 head next

28 Link* List::copy() const { //deep copy of this list (allocates links) if (0 == gethead()) { return 0; else { Link *head = new Link(*getHead()); //call copy constructor of Link Link *next = head; for (Link *origptr = gethead()->getnext(); 0!= origptr; origptr = origptr->getnext()) { next->setnext(new Link(*origPtr));//create a new link for next next = next->getnext(); return head; //origptr points to node in original list that is not yet copied List to copy (this instance of list): List - continued data_ next_ data_ next_ data_ next_ 0 gethead() Temp origptr Copied List: data_ next_ data_ next_ data_ next_ 0 head next

29 List - continued Link* List::copy() const { //deep copy of this list (allocates links) if (0 == gethead()) { return 0; else { Link *head = new Link(*getHead()); Link *next = head; for (Link *origptr = gethead()->getnext(); 0!= origptr; origptr = origptr->getnext()) { next->setnext(new Link(*origPtr)); next = next->getnext(); return head; List::List(const List &alist){ //Copy Constructor:deep copy of alist head_ = alist.copy(); List & List::operator=(const List &L) { //Assignment Operator if (this == &L) { //check for "self assignment" and do nothing in that case return *this; clear(); head_ = L.copy(); return *this;

30 Destructor An object's destructor function is called when that object is about to "go away. - A class instance (a value parameter or a local variable) goes out of scope - The dynamically allocated storage pointed to by the pointer is freed by the programmer using the delete operator

31 Destructor void f(list L) { //what is the scope of L? List *p = new List(); //what is the scope of P? while (...) { List L1; //what is the scope of L1?... delete p;

32 Destructor void f(list L) { //(object passed by value) copy constructor function was called List *p = new List(); //object's constructor function is called while (...) { List L1; //L1's constructor function is called... //L1's destructor function is called delete p; //object's destructor function is called //L's destructor function is called Is a destructor function of a reference parameter called at the end of the function?

33 // deceleration of detructor - always declared as virtual virtual ~List(); /** * Destructor: "deep delete" */ List::~List() { clear(); void List::removeFirst() { if (0!= head_) { Link* tmp = head_; head_ = head_->getnext(); delete tmp; void List::clear(){ while (0!= head_) { removefirst();

34 Copy Constructor An object's copy constructor is called (automatically, not by the programmer) when it is created, and needs to be initialized to be a copy of an existing object. This happens when an object is: - Passed as a value parameter to a function, for example: Point q(2,2); Point p(0,0); p.moveto(q); //declared as: moveto(point point) {... Returned (by value) as a function result, Declared with initialization from an existing object of the same class. void f(point p){ Point temp = p; Point temp2(p); //copy constructor called here to copy p //copy constructor called here to copy p

35 Example When copy constructors are being called? List f( List L ) { List tmp1 = L; List tmp2(l);... return tmp1; int main() { List L1, L2;... L2 = f( L1 );

36 Example List f( List L ) { List tmp1 = L; List tmp2(l);... return tmp1; // copy constructor called here to copy L // copy constructor called here to copy L // copy constructor called here // to copy tmp1 to L2 int main() { List L1, L2;... L2 = f( L1 ); // copy constructor called here to copy L1

37 Copy Constructor Declaration class List { public: List(const List &L); // copy constructor //L is the object that the copy constructor is supposed to copy... ; The copy constructor should copy - (sometimes called a deep copy): - the values of all non-pointer data members - the objects pointed to by all pointer data members

38 Copy Constructor Definition List::List(const List &alist){ head_ = alist.copy(); Link* List::copy() const { if (0 == gethead()) { return 0; else { Link *head = new Link(*getHead()); Link *next = head; for (Link *origptr = gethead()->getnext(); 0!= origptr; origptr = origptr->getnext()) { next->setnext(new Link(*origPtr)); next = next->getnext(); return head;

39 List L1, L2; Operator=... L1 = L2; // assignment can be written as: L1.operator=(L2) By default, class assignment is just a field-by-field assignment the above assignment is equivalent to: L1.data_ = L2.data_; L1.next_ = L2.next_; - If a class includes pointer fields, the default assignment operator causes aliasing which lead to trouble! Solution: overload operator= to perform deep copy. Syntax: List & operator=(const List &L);

40 =Operator Note that operator= differs from the copy constructor in 3 important ways: The object being assigned to has already been initialized. Therefore, if it has a pointer field, the storage pointed to, must be freed to prevent a storage leak. It is possible for a programmer to assign from a variable into itself. for example: L1 = L1. The operator= code must check for this case, and do nothing. The operator= code must return a value

41 Definition of operator= It should always include the following 4 sections: - check assignment to self - clear existing data members - copy data member from other - return this List & List::operator=(const List &L) { if (this == &L) { // check for "self assignment" and do nothing in that case return *this; clear(); head_ = L.copy(); return *this; // return this List

42 Objects In C++, object variables hold values, not object references. When one object is assigned to another, a copy of the actual values is made. When modifying an object in a function, you must remember to use call by reference. Two object variables cannot jointly access one object. If you need this effect in C++, then you need to use pointers/references. An object variable can only hold values of a particular type. If you want a variable to hold objects from different subclasses, you need to use pointers. If you want a variable point to either null or to an actual object, then you need to use pointers in C++.

43 The "this" Pointer Note that, as in Java, this is a pointer to the active object. So for example, when: L1 = L2 is executed, L1's member function operator= is called, so this is a pointer to L1. We also make use of this for the returned value in the operator=. the type to be returned is List& so we dereference this, a.k.a return *this. We would like to establish a way to distinguish between parameters and class variables. This can be done by the "this" pointer. It used as a pointer to the class object instance by the member functions. this pointer stores the address of the object instance, to enable pointer access of the object. this pointers are not accessible for static member functions. this pointers are not modifiable.

44 C++ STL examples - Vector void clean_odd(std::vector<int> &vec) { std::vector<int>::iterator iter = vec.begin(); while (iter!= vec.end()) { if (*iter % 2 == 0) { iter++; else { iter = vec.erase(iter); int main(int argc, char *argv[]) { std::vector<int> vec; vec.push_back(0); vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5); Printout clean_odd(vec); for (std::vector<int>::iterator iter = vec.begin(); iter!= vec.end(); ++iter){ std::cout << *iter << std::endl; return 0;

45 C++ STL examples - Map int main(int argc, char *argv[]) { std::map<std::string,int> stringcounts; std::string str; std::vector<string> vec; vec.push_back("abc"); vec.push_back("123"); vec.push_back("qaz"); vec.push_back("789"); vec.push_back("abc"); vec.push_back("123"); Printout word: 123, count: 2 word: 789, count: 1 word: abc, count: 2 word: qaz, count: 1 std::vector<string>::iterator veciter = vec.begin(); while (veciter!= vec.end()) { std::map<std::string,int>::iterator found = stringcounts.find(*veciter); if (found!= stringcounts.end()) { found->second++; else { stringcounts.insert(std::make_pair(*veciter, 1)); veciter++; std::map<std::string,int>::iterator iter; for( iter = stringcounts.begin(); iter!= stringcounts.end(); ++iter) { std::cout << "word: " << iter->first << ", count: " << iter->second << std::endl; return 0;

46 C++ STL examples - Priority Queue class Cow { private: int _id; public: Cow(int id) : _id(id) { ; int getid() const { return _id; // A comparator is a class that implements the operator() // It is passed as a parameter to the priority queue // and used to perform the comparisons among items in the queue. class CowComparator { public: bool operator()(const Cow &x, const Cow &y) { // return true if x < y, false otherwise return x.getid() < y.getid(); ; int main(int argc, char *argv[]) { typedef std::priority_queue<cow, std::vector<cow>, CowComparator> PrioQueue; PrioQueue queue; queue.push(cow(0)); queue.push(cow(3)); queue.push(cow(1)); queue.push(cow(2)); Printout while (!queue.empty()) { std::cout << queue.top().getid() << std::endl; queue.pop();