diff --git a/module-1/homework/SharedPointer/src/control/control.h b/module-1/homework/SharedPointer/src/control/control.h
index b2fc359b..ca32b3ce 100644
--- a/module-1/homework/SharedPointer/src/control/control.h
+++ b/module-1/homework/SharedPointer/src/control/control.h
@@ -4,25 +4,81 @@
 
 class SharedCount {
 public:
-    // Your code goes here...
+    size_t Get() const {
+        return counter_.load();
+    }
+
+    virtual bool Empty() {
+        return counter_ > 0;
+    }
+
+    virtual bool Remove() {
+        if (counter_ == 0) {
+            return false;
+        }
+
+        --counter_;
+        return true;
+    }
+
+    void Add() {
+        ++counter_;
+    }
 
 protected:
-    // Your code goes here...
+    std::atomic<size_t> counter_{0};
 };
 
 class SharedWeakCount : public SharedCount {
 public:
-    // Your code goes here...
+    void AddWeak() {
+        ++weak_counter_;
+    }
+
+    bool RemoveWeak() {
+        if (weak_counter_ == 0) {
+            return false;
+        }
+
+        --weak_counter_;
+        return true;
+    }
+
+    size_t GetWeak() const {
+        return weak_counter_.load();
+    }
+
+    bool Empty() override {
+        return (counter_ == 0) and (weak_counter_ == 0);
+    }
 
 protected:
-    // Your code goes here...
+    std::atomic<size_t> weak_counter_{0};
 };
 
 template <typename T, typename Deleter>
 class ControlBlock : public SharedWeakCount {
 public:
-    // Your code goes here...
+    explicit ControlBlock(T* value) : value_{value} {
+        assert(value_ != nullptr);
+        Add();
+    }
+
+    ControlBlock(ControlBlock&) = delete;
+    void operator=(ControlBlock&) = delete;
+
+    bool Remove() override {
+        if (SharedCount::Remove()) {
+            if (Get() == 0) {
+                Deleter deleter;
+                deleter(value_);
+                value_ = nullptr;
+            }
+            return true;
+        }
+        return false;
+    }
 
 private:
-    // Your code goes here...
+    T* value_;
 };
\ No newline at end of file
diff --git a/module-1/homework/SharedPointer/src/shared_ptr/shared_ptr.h b/module-1/homework/SharedPointer/src/shared_ptr/shared_ptr.h
index 2a60bbcf..5cb1eea2 100644
--- a/module-1/homework/SharedPointer/src/shared_ptr/shared_ptr.h
+++ b/module-1/homework/SharedPointer/src/shared_ptr/shared_ptr.h
@@ -2,6 +2,50 @@
 
 #include "../control/control.h"
 
+template <typename T>
+struct GetPureType {
+    using type = T;
+};
+
+template <typename T>
+struct GetPureType<T[]> {
+    using type = T;
+};
+
+template <typename T, size_t N>
+struct GetPureType<T[N]> {
+    using type = T;
+};
+
+struct TypeDeleter {
+    template <typename T>
+    void operator()(T* p) {
+        delete p;
+    }
+};
+
+struct ArrayDeleter {
+    template <typename T>
+    void operator()(T* p) {
+        delete[] p;
+    }
+};
+
+template <typename T>
+struct ChooseDeleter {
+    using deleter = TypeDeleter;
+};
+
+template <typename T>
+struct ChooseDeleter<T[]> {
+    using deleter = ArrayDeleter;
+};
+
+template <typename T, size_t N>
+struct ChooseDeleter<T[N]> {
+    using deleter = ArrayDeleter;
+};
+
 // SharedPtr
 template <typename T>
 class WeakPtr;
@@ -9,7 +53,8 @@ class WeakPtr;
 template <typename T>
 class SharedPtr {
 public:
-    using element_type =     // Your code goes here...
+    using element_type = typename GetPureType<T>::type;
+    using deleter_type = typename ChooseDeleter<T>::deleter;
 
     constexpr SharedPtr() noexcept = default;
     ~SharedPtr();
@@ -56,24 +101,172 @@ class SharedPtr {
     friend class WeakPtr;
 
 private:
-    // Your code goes here...
+    element_type* value_{nullptr};
+    SharedWeakCount* counter_{nullptr};
 };
 
+template <typename T, typename... Args>
+SharedPtr<T> MakeShared(Args&&... args) {
+    return SharedPtr<T>(new T(std::forward<Args>(args)...));
+}
 
-// MakeShared
-// Your code goes here...
-// MakeShared
+template <typename T>
+SharedPtr<T>::~SharedPtr() {
+    if (counter_) {
+        counter_->Remove();
+        if (counter_->Empty()) {
+            delete counter_;
+        }
+    }
+}
 
-// SharedPtr
-// Your code goes here...
-// SharedPtr
+template <typename T>
+template <typename Y>
+SharedPtr<T>::SharedPtr(Y* p) : value_{p}, counter_{new ControlBlock<Y, deleter_type>(p)} {
+}
+
+template <typename T>
+template <typename Y, typename Deleter>
+SharedPtr<T>::SharedPtr(Y* p, Deleter) noexcept
+    : value_{p}, counter_{new ControlBlock<Y, Deleter>(p)} {
+}
+
+template <typename T>
+SharedPtr<T>::SharedPtr(const SharedPtr& other) noexcept
+    : value_{other.value_}, counter_{other.counter_} {
+    counter_->Add();
+}
+
+template <typename T>
+SharedPtr<T>::SharedPtr(SharedPtr&& other) noexcept
+    : value_{other.value_}, counter_{other.counter_} {
+    other.value_ = nullptr;
+    other.counter_ = nullptr;
+}
+
+template <typename T>
+SharedPtr<T>& SharedPtr<T>::operator=(const SharedPtr& other) noexcept {
+    Reset();
+    value_ = other.value_;
+    counter_ = other.counter_;
+    counter_->Add();
+    return *this;
+}
+
+template <typename T>
+template <typename Y>
+SharedPtr<T>& SharedPtr<T>::operator=(const SharedPtr<Y>& other) noexcept {
+    Reset();
+    value_ = other.value_;
+    counter_ = other.counter_;
+    counter_->Add();
+    return *this;
+}
+
+template <typename T>
+SharedPtr<T>& SharedPtr<T>::operator=(SharedPtr&& other) noexcept {
+    Reset();
+    value_ = other.value_;
+    counter_ = other.counter_;
+    other.value_ = nullptr;
+    other.counter_ = nullptr;
+    return *this;
+}
+
+template <typename T>
+template <typename Y>
+SharedPtr<T>& SharedPtr<T>::operator=(SharedPtr<Y>&& other) noexcept {
+    Reset();
+    value_ = other.value_;
+    counter_ = other.counter_;
+    other.value_ = nullptr;
+    other.counter_ = nullptr;
+    return *this;
+}
+
+template <typename T>
+void SharedPtr<T>::Reset() noexcept {
+    if (counter_) {
+        counter_->Remove();
+        value_ = nullptr;
+        counter_ = nullptr;
+    }
+}
+
+template <typename T>
+template <typename Y>
+void SharedPtr<T>::Reset(Y* p) noexcept {
+    if (counter_) {
+        counter_->Remove();
+        if (counter_->Empty()) {
+            delete counter_;
+        }
+    }
+
+    value_ = p;
+    counter_ = new ControlBlock<Y, deleter_type>(p);
+}
+
+template <typename T>
+template <typename Y, typename Deleter>
+void SharedPtr<T>::Reset(Y* p, Deleter) noexcept {
+    if (counter_) {
+        counter_->Remove();
+        if (counter_->Empty()) {
+            delete counter_;
+        }
+    }
+
+    value_ = p;
+    counter_ = new ControlBlock<Y, Deleter>(p);
+}
+
+template <typename T>
+void SharedPtr<T>::Swap(SharedPtr& other) noexcept {
+    std::swap(counter_, other.counter_);
+    std::swap(value_, other.value_);
+}
+
+template <typename T>
+T* SharedPtr<T>::Get() const noexcept {
+    return value_;
+}
+
+template <typename T>
+int64_t SharedPtr<T>::UseCount() const noexcept {
+    if (counter_ == nullptr) {
+        return 0;
+    }
+    return counter_->Get();
+}
+
+template <typename T>
+T& SharedPtr<T>::operator*() const noexcept {
+    return *value_;
+}
+
+template <typename T>
+T* SharedPtr<T>::operator->() const noexcept {
+    return value_;
+}
+
+template <typename T>
+typename SharedPtr<T>::element_type& SharedPtr<T>::operator[](std::ptrdiff_t idx) const {
+    return value_[idx];
+}
+
+template <typename T>
+SharedPtr<T>::operator bool() const noexcept {
+    return counter_ != nullptr;
+}
 
 // WeakPtr
 template <typename T>
 class WeakPtr {
 
 public:
-    using element_type =     // Your code goes here...
+    using element_type = typename GetPureType<T>::type;
+    using deleter_type = typename ChooseDeleter<T>::deleter;
 
     // Special-member functions
     constexpr WeakPtr() noexcept = default;
@@ -100,9 +293,102 @@ class WeakPtr {
     friend class SharedPtr;
 
 public:
-    // Your code goes here...
+    element_type* value_{nullptr};
+    SharedWeakCount* counter_{nullptr};
 };
 
-// WeakPtr
-// Your code goes here...
-// WeakPtr
\ No newline at end of file
+template <typename T>
+template <typename Y>
+WeakPtr<T>::WeakPtr(const SharedPtr<Y>& other) : value_{other.value_}, counter_{other.counter_} {
+    counter_->AddWeak();
+}
+
+template <typename T>
+WeakPtr<T>::WeakPtr(const WeakPtr& other) noexcept
+    : value_{other.value_}, counter_{other.counter_} {
+    counter_->AddWeak();
+}
+
+template <typename T>
+WeakPtr<T>::WeakPtr(WeakPtr&& other) noexcept : value_{other.value_}, counter_{other.counter_} {
+    other.value_ = nullptr;
+    other.counter_ = nullptr;
+}
+
+template <typename T>
+template <typename Y>
+WeakPtr<T>& WeakPtr<T>::operator=(const SharedPtr<Y>& other) {
+    Reset();
+    value_ = other.value_;
+    counter_ = other.counter_;
+    counter_->AddWeak();
+    return *this;
+}
+
+template <typename T>
+WeakPtr<T>& WeakPtr<T>::operator=(const WeakPtr& other) noexcept {
+    Reset();
+    value_ = other.value_;
+    counter_ = other.counter_;
+    counter_->AddWeak();
+    return *this;
+}
+
+template <typename T>
+WeakPtr<T>& WeakPtr<T>::operator=(WeakPtr&& other) noexcept {
+    Reset();
+    value_ = other.value_;
+    counter_ = other.counter_;
+    other.value_ = nullptr;
+    other.counter_ = nullptr;
+    return this;
+}
+
+template <typename T>
+WeakPtr<T>::~WeakPtr() {
+    if (counter_ == nullptr) {
+        assert(value_ == nullptr);
+        return;
+    }
+
+    counter_->RemoveWeak();
+    if (counter_->Empty()) {
+        delete counter_;
+    }
+}
+
+template <typename T>
+void WeakPtr<T>::Reset() noexcept {
+    if (counter_) {
+        counter_->RemoveWeak();
+        if (counter_->Empty()) {
+            delete counter_;
+        }
+    }
+
+    value_ = nullptr;
+    counter_ = nullptr;
+}
+
+template <typename T>
+void WeakPtr<T>::Swap(WeakPtr<T>& other) noexcept {
+    std::swap(value_, other.value_);
+    std::swap(counter_, other.counter_);
+}
+
+template <typename T>
+bool WeakPtr<T>::Expired() noexcept {
+    return counter_ == nullptr || counter_->Get() == 0;
+}
+
+template <typename T>
+SharedPtr<T> WeakPtr<T>::Lock() const noexcept {
+    SharedPtr<T> shared;
+    if (counter_ == nullptr || counter_->Get() == 0) {
+        return shared;
+    }
+
+    shared.value_ = value_;
+    shared.counter_ = counter_;
+    return shared;
+}
\ No newline at end of file