From e251dbf4e82efc3dcfe18f6d5d00ae3ce079d1bd Mon Sep 17 00:00:00 2001
From: manuel <manuel@nc8430.lan>
Date: Wed, 3 Jun 2009 15:00:12 +0200
Subject: ue5

---
 ue5/verwendung.cpp | 218 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 218 insertions(+)
 create mode 100644 ue5/verwendung.cpp

(limited to 'ue5/verwendung.cpp')

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
+	}
+
+}
-- 
cgit v1.2.3