From e251dbf4e82efc3dcfe18f6d5d00ae3ce079d1bd Mon Sep 17 00:00:00 2001 From: manuel Date: Wed, 3 Jun 2009 15:00:12 +0200 Subject: ue5 --- ue5/Makefile | 35 +++++++++ ue5/angabe.pdf | Bin 0 -> 83330 bytes ue5/array.hpp | 45 +++++++++++ ue5/mean_mark.hpp | 21 ++++++ ue5/shared_ptr.hpp | 85 +++++++++++++++++++++ ue5/verwendung.cpp | 218 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 404 insertions(+) create mode 100644 ue5/Makefile create mode 100644 ue5/angabe.pdf create mode 100644 ue5/array.hpp create mode 100644 ue5/mean_mark.hpp create mode 100644 ue5/shared_ptr.hpp create mode 100644 ue5/verwendung.cpp 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 Binary files /dev/null and b/ue5/angabe.pdf differ 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 & 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 +double mean_mark(Iter first, Iter last); + +template +double mean_mark_student(Iter first, Iter last); + +template +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 +class shared_ptr +{ +private: + /* TODO data */ + +public: + shared_ptr(); + T* get() const; + 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 + shared_ptr& operator = (const shared_ptr& other); + + ~shared_ptr (); + T& operator * () const; + T* operator -> () const; + + void swap (shared_ptr& other); + + inline void reset(); + +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 U2* 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 U1* 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 +shared_ptr make_shared (/* TODO */); + + +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 */ +} + +#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 // for std::size_t +#include // for assert +#include // for std::move +#include // 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 +#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 +#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 +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); + + throw 0; // must be exception safe + } catch (...) + {} + + + { + // derived1 is 0. + shared_ptr derived1; + assert(derived1.get() == 0); + + // Other way for object creation + derived1 = make_shared(3); + assert(derived1.get() != 0); + + // Call object member + derived1->mark(); + + // Object creation with constructor parameters + shared_ptr derived2 = make_shared(4); + assert (derived2.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; + +#ifdef SOLVED_1 + // Explicit downcast possible. Some casts that are available: constCast, + // staticCast, dynamicCast + derived2 = shared_dynamic_cast(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 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 a2 = make_array(); + 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, 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_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> 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_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