From 2935b29e2ea478780a76faa4f3b156ddaf7a4f8a Mon Sep 17 00:00:00 2001 From: GRayHook Date: Mon, 28 Jul 2025 17:03:05 +0700 Subject: [PATCH] add iterable --- .gitignore | 3 +++ Makefile | 11 +++++---- README.md | 24 ++++++++++++++++++ iterable | Bin 0 -> 35720 bytes iterable.cc | 23 +++++++++++++++++ iterators.h | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++ main.h | 43 ++++++++++++++++++++++++++++++++ main.c => raw_ptr.cc | 24 +++++------------- smart_ptr.cc | 44 +++++++++++++++++++++++++++++++++ 9 files changed, 217 insertions(+), 23 deletions(-) create mode 100644 README.md create mode 100755 iterable create mode 100644 iterable.cc create mode 100644 iterators.h create mode 100644 main.h rename main.c => raw_ptr.cc (62%) create mode 100644 smart_ptr.cc diff --git a/.gitignore b/.gitignore index 9e79b4d..751d24b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,5 @@ *.o .*.swp +raw_ptr +smart_ptr +smart_ptr_iterable diff --git a/Makefile b/Makefile index 6d59d74..1150842 100644 --- a/Makefile +++ b/Makefile @@ -1,8 +1,9 @@ -run: wrappers - ./wrappers +run: all + ./raw_ptr + ./smart_ptr + ./iterable -wrappers: main.c - g++ -Wall -o wrappers main.c +all: raw_ptr smart_ptr iterable clean: - rm -f *.o wrappers + rm -f *.o raw_ptr smart_ptr iterable diff --git a/README.md b/README.md new file mode 100644 index 0000000..28e37b4 --- /dev/null +++ b/README.md @@ -0,0 +1,24 @@ +Wrappers and iterators examples +=============================== + +Build and run: + +``` +make +``` + +`raw_ptr.cc` +------------ + +Simply raw pointer wrapper. Shows how we can do an object abilities extension in the runtime. Useful for iterators. + +`smart_ptr.cc` +-------------- + +Similar example, but holds the shared pointer. + +`iterable.cc` +------------- + +Finally, the iterable with traversing algorithm compile-time instantiated. The template method returns an iterable object, which iterates over IShape's with its `.get_next()`/`.get_prev()`. + diff --git a/iterable b/iterable new file mode 100755 index 0000000000000000000000000000000000000000..c5edc7c558853599852cf94bb6d2063364ff7803 GIT binary patch literal 35720 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 +#include + +#include "main.h" + +int main() { + auto c1 = std::make_shared(3.0); + auto c2 = std::make_shared(5.0); + auto c3 = std::make_shared(7.0); + + c1->set_next(c2.get()); + c2->set_next(c3.get()); + + std::cout << "Forward:\n"; + for (auto& shape : c1->traverse()) { + shape.draw(); + } + + std::cout << "\nBackward:\n"; + for (auto& shape : c1->traverse()) { + shape.draw(); + } +} diff --git a/iterators.h b/iterators.h new file mode 100644 index 0000000..43e27e1 --- /dev/null +++ b/iterators.h @@ -0,0 +1,68 @@ +#pragma once + +template +class Iterator { +protected: + T* current; +public: + explicit Iterator(T* ptr) : current(ptr) {} + + T& operator*() const { return *current; } + T* operator->() const { return current; } + + bool operator!=(const Iterator& other) const { + return current != other.current; + } + + virtual Iterator& operator++() = 0; +}; + +template +class Traversal { + T* start; + +public: + explicit Traversal(T* start) : start(start) {} + + Policy begin() const { return Policy(start); } + Policy end() const { return Policy(nullptr); } +}; + +template +struct IteratorForward : public Iterator { + explicit IteratorForward(T* ptr) : Iterator(first(ptr)) {} + + static T* first(T* node) { + return node; + } + + static T* next(T* node) { + return node ? node->get_next() : nullptr; + } + + Iterator& operator++() override { + this->current = next(this->current); + return *this; + } +}; + +template +struct IteratorBackward : public Iterator { + explicit IteratorBackward(T* ptr) : Iterator(first(ptr)) {} + + static T* first(T* node) { + if (!node) return nullptr; + while (node->get_next()) node = node->get_next(); + return node; + } + + static T* next(T* node) { + return node ? node->get_prev() : nullptr; + } + + Iterator& operator++() override { + this->current = next(this->current); + return *this; + } +}; + diff --git a/main.h b/main.h new file mode 100644 index 0000000..5a3339e --- /dev/null +++ b/main.h @@ -0,0 +1,43 @@ +#pragma once + +#include "iterators.h" + +class IShape { + IShape* next = nullptr; + IShape* prev = nullptr; + +public: + virtual ~IShape() = default; + virtual void draw() const = 0; + virtual double area() const = 0; + + void set_next(IShape* n) { + next = n; + if (n) n->prev = this; + } + + IShape* get_next() const { return next; } + IShape* get_prev() const { return prev; } + + template + Traversal traverse() { + return Traversal(this); + } + + using forward = IteratorForward; + using backward = IteratorBackward; +}; + +class Circle : public IShape { + double r; +public: + Circle(double radius) : r(radius) {} + + void draw() const override { + std::cout << "Drawing Circle of radius " << r << "\n"; + } + + double area() const override { + return 3.14159 * r * r; + } +}; diff --git a/main.c b/raw_ptr.cc similarity index 62% rename from main.c rename to raw_ptr.cc index f4a8e19..bbf2f0d 100644 --- a/main.c +++ b/raw_ptr.cc @@ -1,17 +1,5 @@ #include - -struct IShape { - virtual void draw() const = 0; - virtual ~IShape() = default; -}; - -class Circle : public IShape { -public: - void draw() const override { - std::cout << "Circle::draw()\n"; - } -}; - +#include "main.h" template class Wrapper { @@ -39,12 +27,12 @@ void render_shape_by_ref(IShape& shape) { } int main() { - Circle c; - Wrapper w(&c); + Circle circle {10}; + Wrapper wrapped(&circle); - w->draw(); + std::cout << wrapped->area() << "\n"; - render_shape_by_ptr(w); + render_shape_by_ptr(wrapped); - render_shape_by_ref(w); + render_shape_by_ref(wrapped); } diff --git a/smart_ptr.cc b/smart_ptr.cc new file mode 100644 index 0000000..a91e93c --- /dev/null +++ b/smart_ptr.cc @@ -0,0 +1,44 @@ +#include +#include +#include "main.h" + +template +class Wrapper { + std::shared_ptr impl; + +public: + explicit Wrapper(std::shared_ptr ptr) : impl(std::move(ptr)) {} + + T* operator->() { return impl.get(); } + const T* operator->() const { return impl.get(); } + + std::shared_ptr get() const { return impl; } + + operator std::shared_ptr() const { return impl; } + operator const std::shared_ptr&() const { return impl; } + operator std::shared_ptr&() { return impl; } + + void myHelper() const { + std::cout << "[Wrapper] Helper method called\n"; + } +}; + +void draw_shape(const std::shared_ptr& shape) { + shape->draw(); +} + +int main() { + auto circle = std::make_shared(10.0); + Wrapper wrapped(circle); + + wrapped->draw(); + + std::cout << "Area: " << wrapped->area() << "\n"; + + wrapped.myHelper(); + + draw_shape(wrapped); + + std::shared_ptr copy = wrapped; + draw_shape(copy); +}