ошибка в ооп С++

Question

Я новичок в ооп и хочу переписать реализацию стека c минимумом под ООП - вариант. Изначально реализовывал стек с минимумом без класса. Минимум поддерживаю вторым стеком (в него добавляю минимум из двух чисел: того, которое вставляем в стек и минимума всех предыдущих чисел в стеке). При ООП-реализации программа работает некорректно и всегда возвращает size = 0, также не работают back, pop. Помогите пожалуйста сделать корректную ООП-реализацию.

push - добавить элемент в стек (также добавляю минимум в стек минимумов)

pop - удалить и вывести последний элемент стека

back - вывести последний элемент стека

clear - очистить стек

size - вернуть размер стека

min - вернуть минимум в стеке

реализация стека без ООП:

#include <iostream>

#include <algorithm>

long int stack[2 * 1000000];
long int stackmin[2 * 1000000];
int s = 0;

void Push(long int n) {
  if (s == 0) {
    stack[s] = n;
    stackmin[s] = n;
    std::cout << "ok";
  } else {
    stack[s] = n;
    stackmin[s] = std::min(stackmin[s - 1], n);
    std::cout << "ok";
  }
  ++s;
}

void Pop() {
  if (s != 0) {
    --s;
    std::cout << stack[s];
  } else {
    std::cout << "error";
  }
}

void Back() {
  if (s != 0) {
    std::cout << stack[s - 1];
  } else {
    std::cout << "error";
  }
}

void Clear() {
  s = 0;
  std::cout << "ok";
}

void Size() { std::cout << s; }

void Min(){
  if (s != 0){
    std::cout << stackmin[s - 1];
  } else {
    std::cout << "error";
  }
}

void ChooseFunc(const std::string& stroka) {
  if (stroka == "push") {
    int x;
    std::cin >> x;
    Push(x);
  }
  if (stroka == "pop") {
    Pop();
  }
  if (stroka == "back") {
    Back();
  }
  if (stroka == "size") {
    Size();
  }
  if (stroka == "clear") {
    Clear();
  }
  if (stroka == "min") {
    Min();
  }
  std::cout << "\n";
}

int main() {
  std::string str;
  while (std::cin >> str) {
    ChooseFunc(str);
  }
}

моя попытка переделать реализацию в класс:

#include <iostream>

#include <algorithm>


class MyStack{
public:
  long int mas[2 * 100000];
  long int masmin[2 * 100000];
  int size = 0;

  void Push(long int n){
    if (size == 0){
      mas[size] = n;
      masmin[size] = n;
      std::cout << "ok";
    } else {
      mas[size] = n;
      masmin[size] = std::min(masmin[size - 1], n);
      std::cout << "ok";
    }
    ++size;
  }

  void Pop() {
    if (size != 0) {
      --size;
      std::cout << mas[size];
    } else {
      std::cout << "error";
    }
  }

  void Back() {
    if (size != 0) {
      std::cout << mas[size - 1];
    } else {
      std::cout << "error";
    }
  }

  void Clear() {
    size = 0;
    std::cout << "ok";
  }

  void Size() { std::cout << size; }

  void Min(){
    if (size != 0){
      std::cout << masmin[size - 1];
    } else {
      std::cout << "error";
    }
  }
};


void ChooseFunc(MyStack stack, const std::string& stroka) {
  if (stroka == "push") {
    int x;
    std::cin >> x;
    stack.Push(x);
  }
  if (stroka == "pop") {
    stack.Pop();
  }
  if (stroka == "back") {
    stack.Back();
  }
  if (stroka == "size") {
    stack.Size();
  }
  if (stroka == "clear") {
    stack.Clear();
  }
  if (stroka == "min") {
    stack.Min();
  }
  std::cout << "\n";
}

int main() {
  MyStack stack;
  std::string str;
  while (std::cin >> str) {
    ChooseFunc(stack, str);
  }
}

Answer 1

Я бы делал так:

class MinStack
{
private:
    int * stk;
    size_t capacity, size_;
    int m = 0;
    void resize_()
    {
        if (capacity == size_)
        {
            int * tmp = new int[capacity *= 2];
            for(size_t i = 0; i < size_; ++i)
                tmp[i] = stk[i];
            delete[] stk;
            stk = tmp;
        }
    }
    void swap(MinStack& s)
    {
        std::swap(stk,s.stk);
        std::swap(capacity,s.capacity);
        std::swap(size_,s.size_);
        std::swap(m,s.m);
    }
public:
    MinStack(size_t sz = 16):stk(new int[sz+1]),capacity(sz+1),size_(0){}
    ~MinStack()
    {
        delete[] stk;
    }
    MinStack(const MinStack& s):stk(new int[s.size_]),capacity(s.size_)
        ,size_(s.size_),m(s.m)
    {
        for(size_t i = 0; i < s.size_; ++i)
            stk[i] = s.stk[i];
    }
    MinStack& operator = (const MinStack& s)
    {
        MinStack tmp(s);
        swap(tmp);
        return *this;
    }

    void push(int i)
    {
        resize_();
        m = (size_ == 0) ? i : std::min(m,i);
        stk[size_++] = i;
    }
    bool empty() const
    {
        return size_ == 0;
    }
    int pop()
    {
        if (empty()) throw runtime_error("pop from empty stack");
        int r = stk[--size_];
        if (r == m && size_) m = *std::min_element(stk,stk+size_);
        return r;
    }
    int min() const
    {
        if (empty()) throw runtime_error("min from empty stack");
        return m;
    }
    int back() const
    {
        if (empty()) throw runtime_error("back from empty stack");
        return stk[size_-1];
    }
    void clear()
    {
        size_ = 0;
    }
    size_t size() const { return size_; }
};

Ну вот не дело стека самому читать и выводить данные... Нарушается сам принцип ООП, по большому счету... Но если очень хотите нарушить — уж чтение и вывод допишите сами, у меня рука не поднимается :)

См. https://ideone.com/6bv5Xh

БЛОГ НА HUSL

ошибка в ооп С++

Ответы (1 шт):