stack_array_t_prj/stack_array_t/stack_array_t.hpp - main - dolpement/OOP

stack_array_t_prj/stack_array_t/stack_array_t.hpp
204 строки5 KB
dolpement
OOP
16 июл 2025, 15:40
16 июл 2025, 15:40d149512
#ifndef STACKARRT_HPP
#define STACKARRT_HPP

#include <initializer_list> 
#include <stdexcept>       
#include <utility>         
#include <cstddef>         

template <typename T>
class StackArrT {
public:
	StackArrT();
	~StackArrT();
	StackArrT(const StackArrT<T>& other);
	StackArrT(StackArrT<T>&& other);
	StackArrT(const std::initializer_list<T>& list);

	void push(const T& value);
	void pop();
	T& top() const;
	void swap(StackArrT<T>& other);
	void merge(StackArrT<T>& other);

	bool empty() const;
	std::ptrdiff_t size() const;

	bool operator==(const StackArrT<T>& rhs) const;
	bool operator!=(const StackArrT<T>& rhs) const;

	StackArrT<T>& operator=(const StackArrT<T>& rhs) noexcept;
	StackArrT<T>& operator=(StackArrT<T>&& other);
private:
    std::ptrdiff_t size_ = 0;   //!< число элементов в буфере
    std::ptrdiff_t i_top_ = -1; //!< индекс top элемента
    T* data_ = nullptr;   //!< элементы стека
};


template <typename T>
inline StackArrT<T>::StackArrT() : size_(0), i_top_(-1), data_(nullptr) {}

template <typename T>
inline StackArrT<T>::~StackArrT(){
    delete[] data_;
}

template <typename T>
inline StackArrT<T>::StackArrT(const StackArrT<T> &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];
    }
}

template <typename T>
inline StackArrT<T>::StackArrT(StackArrT<T> &&other) : size_(other.size_), i_top_(other.i_top_), data_(other.data_) {
    other.data_ = nullptr;
    other.i_top_ = -1;
    other.size_ = 0;
}

template <typename T>
inline StackArrT<T>::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;
    }
}

template <typename T>
inline void StackArrT<T>::push(const T &value){
    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;
}

template <typename T>
inline void StackArrT<T>::pop() { 
    if (i_top_ < 0) {
        throw std::out_of_range("Стек пустой");
    }
    --i_top_;
}

template <typename T>
inline T &StackArrT<T>::top() const {
    if (i_top_ < 0) {
        throw std::out_of_range("Стек пустой");
    }
    return data_[i_top_];
}

template <typename T>
inline void StackArrT<T>::swap(StackArrT<T> &other) {
    std::swap (data_ ,other.data_);
    std::swap (size_, other.size_);
    std::swap (i_top_, other.i_top_);
}

template <typename T>
inline void StackArrT<T>::merge(StackArrT<T>& 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;
}

template <typename T>
inline bool StackArrT<T>::empty() const {
    return i_top_ == -1;
}

template <typename T>
inline std::ptrdiff_t StackArrT<T>::size() const {
    return i_top_ + 1;
}

template <typename T>
inline bool StackArrT<T>::operator==(const StackArrT<T> &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;
}

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

template <typename T>
inline StackArrT<T> &StackArrT<T>::operator=(const StackArrT<T> &rhs) noexcept {
    if (this != &rhs) {
        StackArrT<T> temp(rhs);
        swap(temp);
    }
    return *this;

    
}

template <typename T>
inline StackArrT<T> &StackArrT<T>::operator=(StackArrT<T> &&other){
    if (this != &other) {
        delete[] data_;
        size_ = other.size_;
        i_top_ = other.i_top_;
        data_ = other.data_;

        other.data_ = nullptr;
        other.size_ = 0;
        other.i_top_ = -1;
    }
    return *this;
}

#endif