General Computer Science II Course: B International University Bremen Date: Dr. Jürgen Schönwälder Deadline:

Transcription

1 General Computer Science II Course: B International University Bremen Date: Dr. Jürgen Schönwälder Deadline: Problem Sheet #7 This problem sheet focusses on C++ casting operators and friend classes. It might also be useful to refresh your knowledge about these C++ concept before working on the problems. Make sure your source code is readable and well organized and that runtime errors are handled in an appropriate way. Check that g++ -Wall -O2 does not report any errors/warnings and that the source code has consistent indentation (run indent with appropriate options in case you cannot indent properly yourself). Problem 7.1: C++ casting operators (5 points) Explain the difference between the two C++ casting operators static cast and dynamic cast. What happens if the type cast is invalid and cannot be performed? Provide examples to demonstrate and explain the behavior of static cast and dynamic cast. A dynamic cast uses runtime type information (RTTI) to determine at runtime whether the type cast is valid. If the cast is not valid, dynamic cast returns 0 for pointer type and the std::bad cast exception for reference types. A static cast uses only compile-time type information to determine the potential correctness of the type cast. class A virtual void needed() ; ; class B : public A ; int main() A a = new A(); B b = new B(); A ap; B bp; ap = dynamic_cast<a> (b); bp = dynamic_cast<b> (a); // not OK, bp will be set to 0 dynamic_cast<a&> (b); dynamic_cast<b&> (a); // not OK, std::bad_cast exception a = static_cast<a> (b); ap = dynamic_cast<a> (b); bp = dynamic_cast<b> (a); dynamic_cast<a&> (b); dynamic_cast<b&> (a); return 0; Problem 7.2: C++ friend classes (5 points) The friend keyword in C++ allows to declare function, operators or other classes as friends. Explain why friend classes, operators and functions are sometimes needed and what the implications of using the friend keyword are.

2 The friend C++ keyword allows to give functions or classes access to protected or private internals of a given class. In other words, friend functions and classes break the idea of encapsulation. A common reason for friend functions is operator overloading. The global << operator usually requires access to internals of a class. Another reasons are classes that work closely together where the direct access to internals provides significant performance improvements or where it is not useful to generally make internals accessible even though some classes require such an access to internals As a general rule, friends should be picked with great care. Note that friends relationships are not transitive the friends of my friends are not automatically my friends. Furthermore, friend relationships are not inherited the children of my friends are not automatically also my friends. Problem 7.3: containers without templates (10 points) Instead of using template classes to realize a container, one can define a base class from which all container elements are derived. We will look at this approach by using a simplified example. Consider the following class declarations: container/container.h -- A simple container class which maintains a set of elements. Instances of classes derived from the class Element can be added to the container. This approach to realize containers requires runtime type casts to downcast Element instances to the real contained classes. / #ifndef _CONTAINER_H_ #define _CONTAINER_H_ class Element Element(); Element next(); Element prev(); virtual Element copy(); // poor man s iterator // poor man s iterator // create a deep copy Element _next; Element _prev; friend class Container; ; class Container Container(); Container(Container &c); ~Container(); const Container& operator=(const Container &c); void add(element e); void remove(element e); Element first(); Element last();

3 ; Element _first; Element _last; #endif Implement these classes by using a doubly linked list. To test your implementation, write a C++ module which adds int and float values to a container and displays them again on standard output. Note that you have to derive specific classes from the Element class to hold int or float values. container/container.cpp -- Implementation of the generic Container and Element classes. / #include "Container.h" #include <stdlib.h> Element::Element() _next = NULL; _prev = NULL; Element Element::next() return _next; Element Element::prev() return _prev; Element Element::copy() return new Element(this); Container::Container() _first = NULL; _last = NULL; Container::Container(Container &c) Element e; _first = NULL; _last = NULL; for (e = c.first(); e; e = e->next()) add(e->copy()); Container::~Container()

4 Element e; for (e = _first; e; e = e->next()) delete e; Element Container::first() return _first; Element Container::last() return _last; void Container::add(Element e) if (! _last) e->_next = e->_prev = NULL; _first = _last = e; else _last->_next = e; e->_prev = _last; _last = e; void Container::remove(Element e) Element x; for (x = _first; x && x!= e; x = x->_next) ; if (x) if (x->_prev) x->_prev->_next = x->_next; else _first = x->_next; if (x->_next) x->_next->_prev = x->_prev; else _last = x->_prev; delete x; container/mixed.cpp -- / #include "Container.h" #include <iostream> class IntElement : public Element IntElement(int i) _value = i;

5 void value(int i) _value = i; int value() return _value; virtual Element copy() return new IntElement(this); int _value; ; class FloatElement : public Element FloatElement(float f) _value = f; void value(float f) _value = f; float value() return _value; virtual Element copy() return new FloatElement(this); float _value; ; static void print(container &c) Element e; IntElement ip; FloatElement fp; for (e = c.first(); e; e = e->next()) ip = dynamic_cast<intelement> (e); fp = dynamic_cast<floatelement> (e); if (ip) std::cout << ip->value() << std::endl; if (fp) std::cout << fp->value() << std::endl; int main(int argc, char argv) Container c; int i; float f; for (i = 0; i < 10; i++) c.add(new IntElement(i)); for (f = 0.0; f < 1; f += 0.1) c.add(new FloatElement(f)); print(c); return 0;