ue5

6 files changed, 404 insertions, 0 deletions

diff --git a/ue5/Makefile b/ue5/Makefile
new file mode 100644
index 0000000..2c98aaa
--- /dev/null
+++ b/ue5/Makefile
@@ -0,0 +1,35 @@
+# Makefile for ue5
+# Author:       Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+# Created:      03.06.2009
+
+CXX=            g++43
+LD=             $(CXX)
+DEBUGFLAGS=     -DNDEBUG
+CXXFLAGS=       -O -std=c++0x -pedantic -Wall $(DEBUGFLAGS)
+LDFLAGS=
+
+BIN=            c++0x
+OBJS=           verwendung.o
+HEADERS=        array.hpp mean_mark.hpp shared_ptr.hpp
+
+.SUFFIXES: .cpp .o
+
+all: $(BIN)
+
+.cpp.o:
+        $(CXX) $(CXXFLAGS) -c $< -o $@
+
+$(OBJS): $(HEADERS)
+
+$(BIN): $(OBJS)
+        $(LD) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
+
+debug:
+        @$(MAKE) all "DEBUGFLAGS=-DDEBUG -g"
+
+clean:
+        rm -f $(OBJS) $(BIN)
+
+.PHONY: clean
+
+# vim600: noet sw=8 ts=8
diff --git a/ue5/angabe.pdf b/ue5/angabe.pdf
new file mode 100644
index 0000000..1131747
--- /dev/null
+++ b/ue5/angabe.pdf
diff --git a/ue5/array.hpp b/ue5/array.hpp
new file mode 100644
index 0000000..19cdc02
--- /dev/null
+++ b/ue5/array.hpp
@@ -0,0 +1,45 @@
+#ifndef ARRAY_H
+#define ARRAY_H
+
+#undef SOLVED_2
+//#define SOLVED_2
+
+/* TODO Includes */
+
+namespace Ti
+{
+
+/* TODO */
+struct array
+{
+        /* TODO typedef */
+
+        /* TODO static_assert */
+
+        /* TODO:
+        void fill (const T& u);
+        void swap (array<T,N> & other);
+        iterator begin();
+        const_iterator begin() const;
+        iterator end();
+        const_iterator end() const;
+        size_type size() const;
+        size_type max_size() const;
+        bool empty() const;
+        reference operator[] (size_type n);
+        const_reference operator[] (size_type n) const;
+        reference at(size_type n);
+        const_reference at (size_type n) const;
+        T* data();
+        */
+
+private:
+        /* TODO data */
+};
+
+/* TODO */
+array/* TODO */&& make_array();
+
+} // namespace
+
+#endif
diff --git a/ue5/mean_mark.hpp b/ue5/mean_mark.hpp
new file mode 100644
index 0000000..671090a
--- /dev/null
+++ b/ue5/mean_mark.hpp
@@ -0,0 +1,21 @@
+#ifndef MEAN_MARK_H
+#define MEAN_MARK_H
+
+#undef SOLVED_3
+//#define SOLVED_3
+
+namespace Ti
+{
+
+template <typename Iter>
+double mean_mark(Iter first, Iter last);
+
+template <typename Iter>
+double mean_mark_student(Iter first, Iter last);
+
+template <class ForwardIterator>
+ForwardIterator remove_greater (ForwardIterator first, ForwardIterator last, int mark);
+
+}
+
+#endif
diff --git a/ue5/shared_ptr.hpp b/ue5/shared_ptr.hpp
new file mode 100644
index 0000000..87e4b01
--- /dev/null
+++ b/ue5/shared_ptr.hpp
@@ -0,0 +1,85 @@
+#ifndef SHARED_PTR_H
+#define SHARED_PTR_H
+
+/* TODO includes */
+
+#undef SOLVED_1
+//#define SOLVED_1
+
+namespace Ti {
+
+/* TODO helpers */
+
+template <typename T>
+class shared_ptr
+{
+private:
+        /* TODO data */
+
+public:
+        shared_ptr();
+        T* get() const;
+        shared_ptr (const shared_ptr<T>& other);
+
+        template <typename O>
+        shared_ptr (const shared_ptr<O>& other);
+
+        template <typename O>
+        explicit shared_ptr (O* p);
+        shared_ptr& operator = (const shared_ptr<T>& other);
+
+        template <typename O>
+        shared_ptr& operator = (const shared_ptr<O>& other);
+
+        ~shared_ptr ();
+        T& operator * () const;
+        T* operator -> () const;
+
+        void swap (shared_ptr<T>& other);
+
+        inline void reset();
+
+private:
+        template <typename R, typename... Args>
+        friend shared_ptr<R> make_shared (Args...);
+
+        template<typename U1, typename U2>
+        friend bool operator == (const shared_ptr<U1>& a, const shared_ptr<U2>& b);
+
+        template<typename U1, typename U2>
+        friend bool operator == (const shared_ptr<U1>& a, const U2* b);
+
+        template<typename U1, typename U2>
+        friend bool operator == (const U1* a, const shared_ptr<U2>& b);
+
+        template<typename U1, typename U2>
+        friend bool operator != (const shared_ptr<U1>& a, const U2* b);
+
+        template<typename U1, typename U2>
+        friend bool operator != (const U1* a, const shared_ptr<U2>& b);
+
+        template<typename U1, typename U2>
+        friend bool operator != (const shared_ptr<U1>& a, const shared_ptr<U2>& b);
+
+        template <typename R, typename F>
+        friend shared_ptr<R> shared_dynamic_cast (const shared_ptr<F>& from);
+};
+
+
+template <typename T /* TODO */ >
+shared_ptr<T> make_shared (/* TODO */);
+
+
+template <typename T, typename F>
+shared_ptr<T> shared_dynamic_cast (const shared_ptr<F>& from);
+
+} // end namespace ti
+
+namespace std {
+        using namespace Ti;
+        template <typename T>
+        inline void swap (shared_ptr<T>& t1, shared_ptr<T>& t2);
+        /* TODO */
+}
+
+#endif
diff --git a/ue5/verwendung.cpp b/ue5/verwendung.cpp
new file mode 100644
index 0000000..b3506c0
--- /dev/null
+++ b/ue5/verwendung.cpp
@@ -0,0 +1,218 @@
+#include <cstddef> // for std::size_t
+#include <cassert> // for assert
+#include <utility> // for std::move
+#include <stdexcept> // for std::out_of_range
+
+struct Person
+{
+        Person (){}
+        virtual int mark(){ return 0; }
+        virtual ~Person(){}
+};
+
+struct Student : Person
+{
+        int m_mark;
+        Student (int mark) :
+                m_mark(mark)
+        {}
+        int mark()
+        {
+                return m_mark;
+        }
+};
+
+struct Pupil : Person
+{
+        int m_mark;
+        Pupil (int mark) :
+                m_mark(mark)
+        {}
+        int mark()
+        {
+                return m_mark;
+        }
+};
+
+#include <memory>
+#include "shared_ptr.hpp"
+
+#ifdef SOLVED_1
+using Ti::shared_ptr;
+using Ti::make_shared;
+using Ti::shared_dynamic_cast;
+#else
+using std::shared_ptr;
+using std::make_shared;
+#endif
+
+#include <array>
+#include "array.hpp"
+
+#ifdef SOLVED_2
+using Ti::array;
+using Ti::make_array;
+#else
+using std::array;
+#endif
+
+#include "mean_mark.hpp"
+#ifdef SOLVED_3
+using Ti::mean_mark;
+using Ti::mean_mark_student;
+using Ti::remove_greater;
+#endif
+
+#include <vector>
+using std::vector;
+
+int main()
+{
+        try {
+                // initialize with new expression
+                shared_ptr<Student> n1 (new Student(5));
+                assert (n1.get() != 0);
+                shared_ptr<Person> n2 (new Person);
+                assert (n2.get() != 0);
+
+                throw 0; // must be exception safe
+        } catch (...)
+        {}
+
+
+        {
+                // derived1 is 0.
+                shared_ptr<Student> derived1;
+                assert(derived1.get() == 0);
+
+                // Other way for object creation
+                derived1 = make_shared<Student>(3);
+                assert(derived1.get() != 0);
+
+                // Call object member
+                derived1->mark();
+
+                // Object creation with constructor parameters
+                shared_ptr<Student> derived2 = make_shared<Student>(4);
+                assert (derived2.get() != 0);
+
+                shared_ptr<Person> base1 = make_shared<Person>();
+                assert (base1.get() != 0);
+
+                // Implicit upcast possible. The object make_sharedd in the previous line is
+                // destroyed, because there are no more pointers referencing it.
+                base1 = derived1;
+
+#ifdef SOLVED_1
+                // Explicit downcast possible. Some casts that are available: constCast,
+                // staticCast, dynamicCast
+                derived2 = shared_dynamic_cast<Student>(base1);
+
+                // You can compare pointers.
+                assert(derived1 == derived2);
+#endif
+
+                // Destroy most references to derived instance. References
+                // (but not the object itself) are destroyed if they go out
+                // of scope, or you can force reference destruction by multiple ways.
+                derived1.reset();     // release reference
+                assert(derived1.get() == 0);
+        }
+
+
+        {
+                // array<int, 0> x; // Should fail with static assertion
+
+                typedef array<shared_ptr<Student>, 5> sarray;
+                sarray a;
+                a [0] = shared_ptr<Student>(new Student(2));
+                a [1] = shared_ptr<Student>(new Student(1));
+                a [2] = shared_ptr<Student>(new Student(5));
+                a [3] = shared_ptr<Student>(new Student(4));
+                a [4] = shared_ptr<Student>();
+                assert(a[0].get() != 0);
+                assert(a[4].get() == 0);
+                a [4] = shared_ptr<Student>(new Student(4));
+
+                try {
+                        a.at(5); // throws exception
+                        assert(0);
+                } catch (std::out_of_range const& oor) {
+                        oor.what();
+                } catch (...) {
+                        assert(0);
+                }
+
+#ifdef SOLVED_2
+                array<int,3> a1 = make_array<int,3>();
+                a1.fill(3);
+
+                array<int,3> a2 = make_array<int,3>();
+                a2.fill(4);
+
+                a1.swap(a2);
+                assert(a1[0] == 4);
+                assert(a2[2] == 3);
+#endif
+
+#ifdef SOLVED_3
+                double mean = mean_mark(a.begin(), a.end());
+                assert (mean >= 3.1 || mean <= 3.3);
+
+                double mean_student = mean_mark_student(a.begin(), a.end());
+                assert (mean_student >= 3.1 || mean_student <= 3.3);
+
+                sarray::iterator end = remove_greater(a.begin(), a.end(), 3);
+                double mean2 = mean_mark(a.begin(), end);
+                assert (mean2 >= 1.4 || mean2 <= 1.6);
+#endif
+        }
+
+
+        {
+                typedef array<shared_ptr<Person>, 5> parray;
+                parray m;
+                m [0] = shared_ptr<Student>(new Student(2));
+                m [1] = shared_ptr<Pupil>(new Pupil(1));
+                m [2] = shared_ptr<Student>(new Student(5));
+                m [3] = shared_ptr<Student>(new Student(4));
+                m [4] = shared_ptr<Person>(new Person());
+
+#ifdef SOLVED_3
+                double mean = mean_mark(m.begin(), m.end());
+                assert (mean >= 2.3 || mean <= 2.5);
+
+                double mean_student = mean_mark_student(m.begin(), m.end());
+                assert (mean_student >= 3.6 || mean_student <= 3.8);
+
+                parray::iterator end = remove_greater(m.begin(), m.end(), 3);
+                double mean2 = mean_mark(m.begin(), end);
+                assert (mean2 >= 0.9 || mean2 <= 1.1);
+#endif
+        }
+
+        {
+                vector<shared_ptr<Person>> m;
+                m.push_back(shared_ptr<Student>(new Student(2)));
+                m.push_back(shared_ptr<Pupil>(new Pupil(1)));
+                m.push_back(shared_ptr<Student>(new Student(5)));
+                m.push_back(shared_ptr<Student>(new Student(4)));
+                m.push_back(shared_ptr<Person>(new Person()));
+
+#ifdef SOLVED_3
+                double mean = mean_mark(m.begin(), m.end());
+                assert (mean >= 2.3 || mean <= 2.5);
+
+                double mean_student = mean_mark_student(m.begin(), m.end());
+                assert (mean_student >= 3.6 || mean_student <= 3.8);
+
+                assert(m.size() == 5);
+                m.erase(remove_greater(m.begin(), m.end(), 3), m.end());
+                assert(m.size() == 3);
+
+                double mean2 = mean_mark(m.begin(), m.end());
+                assert (mean2 >= 0.9 || mean2 <= 1.1);
+#endif
+        }
+
+}