stack_base_prj/stack_base/stack_arr_t.hpp - main - dolpement/OOP

stack_base_prj/stack_base/stack_arr_t.hpp
173 строки4 KB
dolpement
OOP
16 июл 2025, 15:40
16 июл 2025, 15:40d149512
#ifndef STACKARRT_HPP
#define STACKARRT_HPP

#include "stack_base.hpp"
#include <initializer_list>
#include <stdexcept>
#include <utility>
#include <cstddef>

template <typename T>
class StackArrT : public IStackBase<T> {
public:
    using value_type = typename IStackBase<T>::value_type;
    
    StackArrT() = default;
    ~StackArrT() { delete[] data_; }
    
    StackArrT(const StackArrT& other) : size_(other.size_), i_top_(other.i_top_) {
        data_ = new T[size_];
        for (std::ptrdiff_t i = 0; i <= i_top_; i++) {
            data_[i] = other.data_[i];
        }
    }
    
    StackArrT(StackArrT&& other) noexcept 
        : size_(other.size_), i_top_(other.i_top_), data_(other.data_) {
        other.data_ = nullptr;
        other.i_top_ = -1;
        other.size_ = 0;
    }
    
    StackArrT(const std::initializer_list<T>& list) 
        : size_(list.size()), i_top_(list.size() - 1) {
        data_ = new T[size_];
        std::ptrdiff_t index = 0;
        for (const auto& item : list) {
            data_[index++] = item;
        }
    }

    void push(const T& value) override {
        if (i_top_ + 1 >= size_) {
            std::ptrdiff_t new_size = (size_ == 0) ? 1 : size_ * 2;
            T* new_data = new T[new_size];
            for (std::ptrdiff_t i = 0; i <= i_top_; ++i) {
                new_data[i] = data_[i];
            }
            delete[] data_;
            data_ = new_data;
            size_ = new_size;
        }
        data_[++i_top_] = value;
    }

    void pop() override {
        if (i_top_ < 0) {
            throw std::out_of_range("Stack underflow");
        }
        --i_top_;
    }

    T& top() const override {
        if (i_top_ < 0) {
            throw std::out_of_range("Stack underflow");
        }
        return data_[i_top_];
    }

    void swap(StackArrT& other) noexcept {
        std::swap(data_, other.data_);
        std::swap(size_, other.size_);
        std::swap(i_top_, other.i_top_);
    }

    void swap(IStackBase<T>& other) override {
        if (auto* p = dynamic_cast<StackArrT*>(&other)) {
            swap(*p);
        } else {
            throw std::invalid_argument("Incompatible stack types for swap");
        }
    }

    void merge(IStackBase<T>& other) override {
        if (auto* p = dynamic_cast<StackArrT*>(&other)) {
            merge(*p);
        } else {
            throw std::invalid_argument("Incompatible stack types for merge");
        }
    }

    void merge(StackArrT& other) {
        std::ptrdiff_t new_size = (i_top_ + 1) + (other.i_top_ + 1);
        T* new_data = new T[new_size];

        for (std::ptrdiff_t i = 0; i <= i_top_; ++i) {
            new_data[i] = data_[i];
        }

        for (std::ptrdiff_t i = 0; i <= other.i_top_; ++i) {
            new_data[i_top_ + 1 + i] = other.data_[i];
        }

        delete[] data_;
        data_ = new_data;
        size_ = new_size;
        i_top_ = new_size - 1;

        other.size_ = 0;
        other.i_top_ = -1;
        delete[] other.data_;
        other.data_ = nullptr;
    }

    bool empty() const override { return i_top_ == -1; }
    std::ptrdiff_t size() const override { return i_top_ + 1; }

    bool operator==(const IStackBase<T>& rhs) const override {
        if (auto* p = dynamic_cast<const StackArrT*>(&rhs)) {
            return *this == *p;
        }
        return false;
    }

    bool operator==(const StackArrT& rhs) const {
        if (i_top_ != rhs.i_top_) return false;
        for (std::ptrdiff_t i = 0; i <= i_top_; ++i) {
            if (data_[i] != rhs.data_[i]) return false;
        }
        return true;
    }

    bool operator!=(const IStackBase<T>& rhs) const override {
        return !(*this == rhs);
    }

    StackArrT& operator=(const StackArrT& rhs) noexcept {
        if (this != &rhs) {
            StackArrT temp(rhs);
            swap(temp);
        }
        return *this;
    }

    StackArrT& operator=(StackArrT&& rhs) noexcept {
        if (this != &rhs) {
            delete[] data_;
            data_ = rhs.data_;
            size_ = rhs.size_;
            i_top_ = rhs.i_top_;
            
            rhs.data_ = nullptr;
            rhs.size_ = 0;
            rhs.i_top_ = -1;
        }
        return *this;
    }

    void printToStream(std::ostream& os) const override {
        os << "{ ";
        for (std::ptrdiff_t i = 0; i <= i_top_; ++i) {
            os << data_[i];
            if (i < i_top_) os << ", ";
        }
        os << " }";
    }

private:
    std::ptrdiff_t size_ = 0;
    std::ptrdiff_t i_top_ = -1;
    T* data_ = nullptr;
};

#endif