Реализовать работу со списком дел на месяц

v1.insert(end(v1), begin(v2), end(v2));

  
12
ADD 5 Salary
ADD 31 Walk
ADD 30 WalkPreparations
NEXT
DUMP 5
DUMP 28
NEXT
DUMP 31
DUMP 30
DUMP 28
ADD 28 Payment
DUMP 28

1 Salary
2 WalkPreparations Walk
0
0
2 WalkPreparations Walk
3 WalkPreparations Walk Payment

 //#include "stdafx.h"
#include <string>
#include <iostream>
#include <vector>
using namespace std;
void Show_tasks(int day, const vector<vector<string>>& tsks) {
    cout << tsks[day - 1].size();
    for (auto i : tsks[day - 1]) {
        cout << " " << i << "\n";
    }
}
void Next_month(int& indx, const vector<int>& dim, vector<vector<string>>& tsks) {
    indx++;
    if (indx > 11)indx = 0;
    vector<vector<string>> NewMonth = tsks;
    int a = tsks.size();
    int b = dim[indx];
    tsks.resize(b);
    const int e = b - 1;
    if (a > b) {
        for (b; a > b; b++) {
            tsks[e].insert(end(tsks[e]), begin(NewMonth[b]), end(NewMonth[b]));
        }
    }
    NewMonth.clear();
}
 
int main()
{
    int q;
    cin >> q;
    vector<int> days_in_month = { 31,28,31,30,31,30,31,31,30,31,30,31 };
    vector<vector<string>> tasks;
    int index_of_month = 0;
    tasks.resize(days_in_month[index_of_month], {});
    for (int i = 0; q > i; i++) {
        string c;
        int d;
        string t;
        cin >> c;
        if (c == "NEXT") {
            Next_month(index_of_month, days_in_month, tasks);
        }
        else if (c == "DUMP") {
            cin >> d;
            Show_tasks(d, tasks);
        }
        else if (c == "ADD") {
            cin >> d >> t;
            tasks[d - 1].push_back(t);
        }
    }
    return 0;
}

1 Salary
2 WalkPreparations
 Walk
002 WalkPreparations
 Walk
3 WalkPreparations
 Walk
 Payment

1 Salary
2 WalkPreparations Walk
0 
0 
2 WalkPreparations Walk
3 WalkPreparations Walk Payment

1 Salary2 WalkPreparations Walk002 WalkPreparations Walk3 WalkPreparations Walk Payment

for (auto i : tsks[day - 1]) {
        cout << " " << i;
    }
 cout << endl

void Show_tasks(int day, const vector<vector<string>>& tsks) {
    cout << tsks[day - 1].size();
    if(day - 1 == 0) {cout <<  endl; return}
    for (auto i : tsks[day - 1]) {
        cout << " " << i << "\n";
    }
}

void Show_tasks(int day, const vector<vector<string>>& tsks) {
    cout << tsks[day - 1].size();
    if(day - 1 == 0) { cout <<  endl; return }
    for (auto i : tsks[day - 1]) {  cout << " " << i; }
    cout <<  endl;
}

void Show_tasks(int day, const vector<vector<string>>& tsks)
{
    cout << tsks[day - 1].size();
    if( tsks[day - 1].size() != 0) 
    {
        for (auto i : tsks[day - 1])
        {
              cout << " " << i;
        }
    }
    else
        { 
              cout <<  endl;
        }
}

1 Salary2 WalkPreparations Walk0
0
2 WalkPreparations Walk3 WalkPreparations Walk Payment

void Show_tasks(int day, const vector<vector<string>>& tsks)
{
    cout << tsks[day - 1].size();
    if( tsks[day - 1].size() != 0) 
    { 
         cout <<  endl; return;
    }
    for (auto i : tsks[day - 1])
    {
         cout << " " << i;
    }
    cout <<  endl;     
}

1
2
0
0
2
3

#include <iostream>
#include <deque>
#include <map>
 
struct Month
{
  const static int        sMonths[];
  constexpr static size_t sMonthsCount = 12;
  int mCurrent = 0;
  int mPrev    = 0;
  
  bool lessAndIncrease()
  {
    mPrev = mCurrent;
    if (mCurrent == sMonthsCount - 1)
    {
      mCurrent = 0;
      return sMonths[mCurrent] < sMonths[sMonthsCount - 1];
    }
    else
    {
      ++mCurrent;
      return sMonths[mCurrent] < sMonths[mCurrent - 1];
    }
  }
};
 
const int Month::sMonths[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
class Calendar;
 
struct ICommand
{
  virtual ~ICommand() = default;
  virtual void input(std::istream & strm) {}
  virtual void execute(Calendar & calendar) = 0;
};
 
enum class CommandType
{
  DUMP,
  NEXT,
  ADD
};
 
class Calendar
{
public:
  void addCase(int day, const std::string & text)
  {
    mDays[day].mCases.push_back(text);
  }
  
  void nextMonth()
  {
    if (mMonth.lessAndIncrease())
    {
      const int day = Month::sMonths[mMonth.mCurrent];
      for (int it = Month::sMonths[mMonth.mCurrent] + 1; it <= Month::sMonths[mMonth.mPrev]; ++it)
      {
        mDays[day].mCases.insert(std::end(mDays[day].mCases), std::begin(mDays[it].mCases), std::end(mDays[it].mCases));
        mDays.erase(it);
      }
    }
    else
    {
      for (int it = Month::sMonths[mMonth.mPrev] + 1; it <= Month::sMonths[mMonth.mCurrent]; ++it)
        mDays.erase(it);
    }
  }
  
  void showCasesByDay(int day, std::ostream & strm) const
  {
    if (mDays.find(day) == mDays.end())
    {
      strm << 0 << "\n";
      return;
    }
    
    strm << mDays.at(day).mCases.size() << " ";
    
    for (const auto & it : mDays.at(day).mCases)
      strm << it << " ";
    strm << "\n";
  }
  
private:
  struct Day
  {
    std::deque<std::string> mCases;
  };
  
  std::map<int, Day>  mDays;
  Month               mMonth;
};
 
class DumpCommand : public ICommand
{
public:
  virtual void input(std::istream & strm) override
  {
    strm >> mDay;
  }
  
  virtual void execute(Calendar & c) override
  {
    c.showCasesByDay(mDay, std::cout);
  }
  
private:
  int mDay;
};
 
class NextCommand : public ICommand
{
public:
  virtual void execute(Calendar & c) override
  {
    c.nextMonth();
  }
};
 
class AddCommand : public ICommand
{
public:
  virtual void input(std::istream & strm) override
  {
    strm >> mDay >> mText;
  }
 
  virtual void execute(Calendar & c) override
  {
    c.addCase(mDay, mText);
  }
  
private:
  int         mDay;
  std::string mText;
};
 
ICommand * createCommand(CommandType command)
{
  switch (command)
  {
  case CommandType::DUMP:
    return new DumpCommand;
  case CommandType::NEXT:
    return new NextCommand;
  case CommandType::ADD:
    return new AddCommand;
  default:
    return nullptr;
  }
}
 
int main()
{
  
  const std::map<std::string, CommandType> commandExec
  {
    { "DUMP", CommandType::DUMP },
    { "NEXT", CommandType::NEXT },
    { "ADD",  CommandType::ADD  }
  };
  
  size_t n{};
  
  std::cin >> n;
  
  std::deque<ICommand *> commands;
  Calendar calendar;
  
  for (size_t it = 0; it < n; ++it)
  {
    std::string s;
    
    std::cin >> s;
    
    commands.push_back(createCommand(commandExec.at(s)));
    commands.back()->input(std::cin);
  }
  
  for (auto & it : commands)
  {
    it->execute(calendar);
  }
}

bool lessAndIncrease()
{
  mPrev = mCurrent;
  if (mCurrent == sMonthsCount - 1)
    mCurrent = 0;
  else
    ++mCurrent;
  return sMonths[mCurrent] < sMonths[mPrev];
}