From 39b0cb9afeb53e9a1720bad64347e72d318c554a Mon Sep 17 00:00:00 2001 From: manuel Date: Wed, 3 Jun 2009 17:26:57 +0200 Subject: replacing 1xtab with 2xspace implementing array --- ue5/Makefile | 3 + ue5/array.hpp | 136 +++++++++++++++++++++------- ue5/mean_mark.hpp | 14 +-- ue5/shared_ptr.hpp | 99 ++++++++++---------- ue5/verwendung.cpp | 258 +++++++++++++++++++++++++++-------------------------- 5 files changed, 295 insertions(+), 215 deletions(-) (limited to 'ue5') 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 // for std::move +#include // for std::out_of_range +#include // for std::fill_n + std::swap_ranges namespace Ti { + template + 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 & 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 not allowed"); + + void fill (const T& u) + { + std::fill_n(begin(), size(), u); + } + + void swap (array & 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 + array&& make_array() + { + return std::move(array()); + } } // 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 -double mean_mark(Iter first, Iter last); + template + double mean_mark(Iter first, Iter last); -template -double mean_mark_student(Iter first, Iter last); + template + double mean_mark_student(Iter first, Iter last); -template -ForwardIterator remove_greater (ForwardIterator first, ForwardIterator last, int mark); + template + 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 -class shared_ptr -{ -private: - /* TODO data */ + template + class shared_ptr + { + private: + /* TODO data */ -public: - shared_ptr(); - T* get() const; - shared_ptr (const shared_ptr& other); + public: + shared_ptr(); + T* get() const; + shared_ptr (const shared_ptr& other); - template - shared_ptr (const shared_ptr& other); + template + shared_ptr (const shared_ptr& other); - template - explicit shared_ptr (O* p); - shared_ptr& operator = (const shared_ptr& other); + template + explicit shared_ptr (O* p); + shared_ptr& operator = (const shared_ptr& other); - template - shared_ptr& operator = (const shared_ptr& other); + template + shared_ptr& operator = (const shared_ptr& other); - ~shared_ptr (); - T& operator * () const; - T* operator -> () const; + ~shared_ptr (); + T& operator * () const; + T* operator -> () const; - void swap (shared_ptr& other); + void swap (shared_ptr& other); - inline void reset(); + inline void reset(); -private: - template - friend shared_ptr make_shared (Args...); + private: + template + friend shared_ptr make_shared (Args...); - template - friend bool operator == (const shared_ptr& a, const shared_ptr& b); + template + friend bool operator == (const shared_ptr& a, const shared_ptr& b); - template - friend bool operator == (const shared_ptr& a, const U2* b); + template + friend bool operator == (const shared_ptr& a, const U2* b); - template - friend bool operator == (const U1* a, const shared_ptr& b); + template + friend bool operator == (const U1* a, const shared_ptr& b); - template - friend bool operator != (const shared_ptr& a, const U2* b); + template + friend bool operator != (const shared_ptr& a, const U2* b); - template - friend bool operator != (const U1* a, const shared_ptr& b); + template + friend bool operator != (const U1* a, const shared_ptr& b); - template - friend bool operator != (const shared_ptr& a, const shared_ptr& b); + template + friend bool operator != (const shared_ptr& a, const shared_ptr& b); - template - friend shared_ptr shared_dynamic_cast (const shared_ptr& from); -}; + template + friend shared_ptr shared_dynamic_cast (const shared_ptr& from); + }; -template -shared_ptr make_shared (/* TODO */); + template + shared_ptr make_shared (/* TODO */); - -template -shared_ptr shared_dynamic_cast (const shared_ptr& from); + template + shared_ptr shared_dynamic_cast (const shared_ptr& from); } // end namespace ti namespace std { - using namespace Ti; - template - inline void swap (shared_ptr& t1, shared_ptr& t2); - /* TODO */ + using namespace Ti; + template + inline void swap (shared_ptr& t1, shared_ptr& 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 @@ -68,151 +68,153 @@ using std::vector; int main() { - try { - // initialize with new expression - shared_ptr n1 (new Student(5)); - assert (n1.get() != 0); - shared_ptr n2 (new Person); - assert (n2.get() != 0); + try { + // initialize with new expression + shared_ptr n1 (new Student(5)); + assert (n1.get() != 0); + shared_ptr 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 derived1; - assert(derived1.get() == 0); + { + // derived1 is 0. + shared_ptr derived1; + assert(derived1.get() == 0); - // Other way for object creation - derived1 = make_shared(3); - assert(derived1.get() != 0); + // Other way for object creation + derived1 = make_shared(3); + assert(derived1.get() != 0); - // Call object member - derived1->mark(); + // Call object member + derived1->mark(); - // Object creation with constructor parameters - shared_ptr derived2 = make_shared(4); - assert (derived2.get() != 0); + // Object creation with constructor parameters + shared_ptr derived2 = make_shared(4); + assert (derived2.get() != 0); - shared_ptr base1 = make_shared(); - assert (base1.get() != 0); + shared_ptr base1 = make_shared(); + 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(base1); + // Explicit downcast possible. Some casts that are available: constCast, + // staticCast, dynamicCast + derived2 = shared_dynamic_cast(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 x; // Should fail with static assertion - - typedef array, 5> sarray; - sarray a; - a [0] = shared_ptr(new Student(2)); - a [1] = shared_ptr(new Student(1)); - a [2] = shared_ptr(new Student(5)); - a [3] = shared_ptr(new Student(4)); - a [4] = shared_ptr(); - assert(a[0].get() != 0); - assert(a[4].get() == 0); - a [4] = shared_ptr(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 x; // Should fail with static assertion + + typedef array, 5> sarray; + sarray a; + a [0] = shared_ptr(new Student(2)); + a [1] = shared_ptr(new Student(1)); + a [2] = shared_ptr(new Student(5)); + a [3] = shared_ptr(new Student(4)); + a [4] = shared_ptr(); + assert(a[0].get() != 0); + assert(a[4].get() == 0); + a [4] = shared_ptr(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 a1 = make_array(); - a1.fill(3); + array a1 = make_array(); + a1.fill(3); - array a2 = make_array(); - a2.fill(4); + array a2 = make_array(); + 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, 5> parray; - parray m; - m [0] = shared_ptr(new Student(2)); - m [1] = shared_ptr(new Pupil(1)); - m [2] = shared_ptr(new Student(5)); - m [3] = shared_ptr(new Student(4)); - m [4] = shared_ptr(new Person()); + { + typedef array, 5> parray; + parray m; + m [0] = shared_ptr(new Student(2)); + m [1] = shared_ptr(new Pupil(1)); + m [2] = shared_ptr(new Student(5)); + m [3] = shared_ptr(new Student(4)); + m [4] = shared_ptr(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> m; - m.push_back(shared_ptr(new Student(2))); - m.push_back(shared_ptr(new Pupil(1))); - m.push_back(shared_ptr(new Student(5))); - m.push_back(shared_ptr(new Student(4))); - m.push_back(shared_ptr(new Person())); + { + vector> m; + m.push_back(shared_ptr(new Student(2))); + m.push_back(shared_ptr(new Pupil(1))); + m.push_back(shared_ptr(new Student(5))); + m.push_back(shared_ptr(new Student(4))); + m.push_back(shared_ptr(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: */ -- cgit v1.2.3