5 files changed, 295 insertions, 215 deletions

diff --git a/ue5/Makefile b/ue5/Makefile
index 2c98aaa..53fd8f5 100644
--- a/ue5/Makefile
+++ b/ue5/Makefile
@@ -30,6 +30,9 @@ debug:
 clean:
         rm -f $(OBJS) $(BIN)
 
+run test: all
+        @./test/test.sh
+
 .PHONY: clean
 
 # vim600: noet sw=8 ts=8
diff --git a/ue5/array.hpp b/ue5/array.hpp
index 19cdc02..37a33b4 100644
--- a/ue5/array.hpp
+++ b/ue5/array.hpp
@@ -2,44 +2,116 @@
 #define ARRAY_H
 
 #undef SOLVED_2
-//#define SOLVED_2
+#define SOLVED_2
 
-/* TODO Includes */
+/* TODO:
+ * Angabe: Im Gegensatz zu den Beispielen bis jetzt ist die Verwendung
+ *         der STL und Boostuntersagt!
+ */
+#include <utility> // for std::move
+#include <stdexcept> // for std::out_of_range
+#include <algorithm> // for std::fill_n + std::swap_ranges
 
 namespace Ti
 {
+  template<typename T, size_t N>
+    struct array
+    {
+      typedef T& reference;
+      typedef const T& const_reference;
+      typedef T* iterator;
+      typedef const T* const_iterator;
+      typedef size_t size_type;
 
-/* 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();
+      static_assert(N != 0, "array<T, 0> not allowed");
+
+      void fill (const T& u)
+      {
+        std::fill_n(begin(), size(), u);
+      }
+
+      void swap (array<T,N> & other)
+      {
+        std::swap_ranges(begin(), end(), other.begin());
+      }
+
+      iterator begin()
+      {
+        return m_data;
+      }
+
+      const_iterator begin() const
+      {
+        return m_data;
+      }
+
+      iterator end()
+      {
+        return m_data + size();
+      }
+
+      const_iterator end() const
+      {
+        return m_data + size();
+      }
+
+      size_type size() const
+      {
+        return N;
+      }
+
+      size_type max_size() const
+      {
+        return N;
+      }
+
+      bool empty() const
+      {
+        return false; /* size() == 0 */
+      }
+
+      reference operator[] (size_type n)
+      {
+        return m_data[n];
+      }
+
+      const_reference operator[] (size_type n) const
+      {
+        return m_data[n];
+      }
+
+      reference at(size_type n)
+      {
+        if (n >= size())
+          throw std::out_of_range("array::at");
+        return m_data[n];
+      }
+
+      const_reference at (size_type n) const
+      {
+        if (n >= size())
+          throw std::out_of_range("array::at");
+        return m_data[n];
+      }
+
+      T* data()
+      {
+        return m_data;
+      }
+
+      private:
+        T m_data[N];
+    };
+
+  /* TODO: was macht std::move() genau?! :) */
+  template<typename T, size_t N>
+    array<T, N>&& make_array()
+  {
+    return std::move(array<T, N>());
+  }
 
 } // namespace
 
 #endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue5/mean_mark.hpp b/ue5/mean_mark.hpp
index 671090a..f35910c 100644
--- a/ue5/mean_mark.hpp
+++ b/ue5/mean_mark.hpp
@@ -7,15 +7,17 @@
 namespace Ti
 {
 
-template <typename Iter>
-double mean_mark(Iter first, Iter last);
+  template <typename Iter>
+    double mean_mark(Iter first, Iter last);
 
-template <typename Iter>
-double mean_mark_student(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);
+  template <class ForwardIterator>
+    ForwardIterator remove_greater (ForwardIterator first, ForwardIterator last, int mark);
 
 }
 
 #endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue5/shared_ptr.hpp b/ue5/shared_ptr.hpp
index 87e4b01..4492fff 100644
--- a/ue5/shared_ptr.hpp
+++ b/ue5/shared_ptr.hpp
@@ -8,78 +8,79 @@
 
 namespace Ti {
 
-/* TODO helpers */
+  /* TODO helpers */
 
-template <typename T>
-class shared_ptr
-{
-private:
-        /* TODO data */
+  template <typename T>
+    class shared_ptr
+    {
+      private:
+        /* TODO data */
 
-public:
-        shared_ptr();
-        T* get() const;
-        shared_ptr (const shared_ptr<T>& other);
+      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>
+          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>
+          explicit shared_ptr (O* p);
+        shared_ptr& operator = (const shared_ptr<T>& other);
 
-        template <typename O>
-        shared_ptr& operator = (const shared_ptr<O>& other);
+        template <typename O>
+          shared_ptr& operator = (const shared_ptr<O>& other);
 
-        ~shared_ptr ();
-        T& operator * () const;
-        T* operator -> () const;
+        ~shared_ptr ();
+        T& operator * () const;
+        T* operator -> () const;
 
-        void swap (shared_ptr<T>& other);
+        void swap (shared_ptr<T>& other);
 
-        inline void reset();
+        inline void reset();
 
-private:
-        template <typename R, typename... Args>
-        friend shared_ptr<R> make_shared (Args...);
+      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 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 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 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 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 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 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 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 /* TODO */ >
+    shared_ptr<T> make_shared (/* TODO */);
 
-
-template <typename T, typename F>
-shared_ptr<T> shared_dynamic_cast (const shared_ptr<F>& from);
+  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 */
+  using namespace Ti;
+  template <typename T>
+    inline void swap (shared_ptr<T>& t1, shared_ptr<T>& t2);
+  /* TODO */
 }
 
 #endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue5/verwendung.cpp b/ue5/verwendung.cpp
index b3506c0..9e10326 100644
--- a/ue5/verwendung.cpp
+++ b/ue5/verwendung.cpp
@@ -5,33 +5,33 @@
 
 struct Person
 {
-        Person (){}
-        virtual int mark(){ return 0; }
-        virtual ~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;
-        }
+  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;
-        }
+  int m_mark;
+  Pupil (int mark) :
+    m_mark(mark)
+  {}
+  int mark()
+  {
+    return m_mark;
+  }
 };
 
 #include <memory>
@@ -68,151 +68,153 @@ 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);
+  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 (...)
-        {}
+    throw 0; // must be exception safe
+  } catch (...)
+  {}
 
 
-        {
-                // derived1 is 0.
-                shared_ptr<Student> derived1;
-                assert(derived1.get() == 0);
+  {
+    // 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);
+    // Other way for object creation
+    derived1 = make_shared<Student>(3);
+    assert(derived1.get() != 0);
 
-                // Call object member
-                derived1->mark();
+    // Call object member
+    derived1->mark();
 
-                // Object creation with constructor parameters
-                shared_ptr<Student> derived2 = make_shared<Student>(4);
-                assert (derived2.get() != 0);
+    // 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);
+    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;
+    // 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);
+    // Explicit downcast possible. Some casts that are available: constCast,
+    // staticCast, dynamicCast
+    derived2 = shared_dynamic_cast<Student>(base1);
 
-                // You can compare pointers.
-                assert(derived1 == derived2);
+    // 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);
-                }
+    // 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> a1 = make_array<int,3>();
+    a1.fill(3);
 
-                array<int,3> a2 = make_array<int,3>();
-                a2.fill(4);
+    array<int,3> a2 = make_array<int,3>();
+    a2.fill(4);
 
-                a1.swap(a2);
-                assert(a1[0] == 4);
-                assert(a2[2] == 3);
+    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 = 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);
+    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);
+    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());
+  {
+    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 = 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);
+    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);
+    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()));
+  {
+    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 = 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);
+    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);
+    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);
+    double mean2 = mean_mark(m.begin(), m.end());
+    assert (mean2 >= 0.9 || mean2 <= 1.1);
 #endif
-        }
+  }
 
 }
+
+/* vim: set et sw=2 ts=2: */