Gromadzenie w wektorze liczb wprowadzonych z klawiatury – program się wykrzacza

Cześć,
Chcę napisać kod, który działa następująco:
a) program działa dopóki nie podamy 0,
b) jeżeli podawane liczby(a) są większe od zera to zapisuje je,
c) jeżeli podana liczba jest mniejsza od zera to wypisuje wartość bezwzględną liczb największych z już podanych i je zapomina.

W kodzie zaznaczyłem gdzie pojawia się problem i program się wykrzacza. Ktoś na to spojrzy i mi pomoże? Z góry dzięki :)

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>

using namespace std;

int main()
{
    int a; int i; //a = podawana liczba, i = licznik ile juz dodano
    vector <int> tab;

    cin >> a;

    int ile;

    while(a != 0)
    {
        if(a < 0 && i > 0)
        {
            ile = abs(a);
            if(ile <= i)
            {
                sort(tab.begin(), tab.end());

                for(int a = tab.size() - 1; a >= tab.size() - ile; a--)
                {
                    cout << tab[a] << " ";
                    i--;
                }//w tym miejscu dziala i wypisuje poprawnie

                for(a = 0; a < ile; a++)
                {
                    tab.pop_back();//po wypisaniu elementu usuwa tyle elementow ile wypisalo
                }
            }
            else
            {
                //jezeli ile > i juz nie dziala
                sort(tab.begin(), tab.end());
                for(int b = tab.size() - 1; b >= 0; b--)
                {
                    cout << tab.at(b) << " ";
                    i--;
                }

                tab.clear();
            }
        }
        else
        {
        tab.push_back(a);
        i++;
        }
        cin >> a;
    }

    return 0;
}

c) jeżeli podana liczba jest mniejsza od zera to wypisuje wartość bezwzględną liczb największych z już podanych i je zapomina.

nie rozumiem tego

wypisuje wartość bezwzględną liczb największych z już podanych i je zapomina.

czyli ignoruje liczby mniejsze od zera i wyswietla najwieksza podana? jezeli tak to po co tutaj wartosc bezwzgledna?

Z podanego a powstaje wartość bezwzględna i wypisuje tyle liczb największych już podanych ile wynosi ta wartość bezwzględna.

no to masz 5 liczb podaje -10 i nie mozesz wyswielic 10 liczb bo masz tylko 5 co wtedy?

Ma wyświetlić 5 liczb i nie robi tego, a wydaje mi się, że pętle została napisana poprawnie

Niepotrzebnie skomplikowałeś sobie kod.

void func()
{
  std::vector< int > values;
  do {
    int val;
    std::cin >> val;
    if ( val > 0 ) {
      values.push_back( val );
    }
    else if ( val < 0 ) {
      std::sort( values.begin(), values.end() );
      auto count = std::min( std::abs( val ), static_cast< int >( values.size() );
      std::copy_n( values.crbegin(), count, std::ostream_iterator< int >( std::cout, " " ) );
      values.erase( values.cbegin(), values.cbegin() + count );
    }
  } while ( val != 0 );
}

tajny_agent napisał(a):

Niepotrzebnie skomplikowałeś sobie kod.

void func()
{
  std::vector< int > values;
  do {
    int val;
    std::cin >> val;
    if ( val > 0 ) {
      values.push_back( val );
    }
    else if ( val < 0 ) {
      std::sort( values.begin(), values.end() );
      auto count = std::min( std::abs( val ), static_cast< int >( values.size() );
      std::copy_n( values.crbegin(), count, std::ostream_iterator< int >( std::cout, " " ) );
      values.erase( values.cbegin(), values.cbegin() + count );
    }
  } while ( val != 0 );
}

Za to twój kod jest kompletnie nieczytelny z powodu sposobu w jaki został sformatowany.

void func()
{
    vector<int> values;

    do
    {
        int val;
        cin >> val;

        if (val > 0)
        {
            values.push_back(val);
        }
        else if (val < 0)
        {
            sort(values.begin(), values.end());
            auto count = min(abs(val), (int)values.size());

            copy_n(values.crbegin(), count, ostream_iterator<int>(cout, " "));
            values.erase(values.cbegin(), values.cbegin() + count);
        }
    } while (val != 0);
}

Oczywiście można toczyć na ten temat niekończącego się flejma, ale nie rozumiem w jaki sposób zaśmiecanie kodu nadmiarowymi znaczkami ma polepszać jego czytelność. Jest dokładnie odwrotnie.