Roman

#include <iostream>
#include <string>
#include <fstream>
#include <sys/utsname.h>

std::string getTimestamp(const std::string& line)
{
  auto pos = line.rfind(' ');
  return line.substr(pos + 1, line.size() - pos);
}

int main(int argc, char* argv[])
{
  if(argc < 3)
  {
    std::cerr << "usage: file timestamp timestamp\n/var/log/syslog 11:00:00 12:00:00\n";
    exit(EXIT_FAILURE);
  }

  struct utsname uts;

  if(uname(&uts) == -1)
  {
    exit(EXIT_FAILURE);
  }

  if(std::ifstream flog(argv[1]); flog)
  {
    std::string start{argv[2]};
    std::string stop {argv[3]};
    std::string line;

    while(getline(flog, line))
    {
      std::string header = getTimestamp(line.substr(0, line.find(uts.nodename) - 1));
      if(header >= start && header <= stop)
      {
        std::cout << line << "\n";
      }
    }
  }
  else
  {
    std::cerr << "Cannot open file: " << argv[1];
  }
}

Где я могу такое найти?

#include<iostream>
#include<string>
#include<vector>
#include<iterator>
#include<memory>
#include<sstream>
#include<Windows.h>
using namespace std;

enum class spType {ALL, SP, TH};

class Policlinic
{
public:
  Policlinic();
  ~Policlinic();
  // ... 
  void addSpecialists(const string& s);
  void addTherapists(const string& s);
  void printPersonnel(spType = spType::ALL);
  // ...
  // Геттеры Сеттеры сам по шаблону
  // ...
private:
  struct Personnel;
  unique_ptr<Personnel> m_personnel;

  string desk;
  string type;

  unsigned pharmacy = 0;

  friend istream& operator>>(istream& is, vector<string>& values);
  friend ostream& operator<<(ostream& os, const vector<string>& values);
};

struct Policlinic::Personnel
{
  vector<string> specialists;
  vector<string> therapists;
};

Policlinic::Policlinic() : m_personnel(make_unique<Personnel>())
{
}

Policlinic::~Policlinic()
{
}

istream& operator>>(istream& is, vector<string>& values)
{
  copy(istream_iterator<string>{is}, {}, back_inserter(values));
  return is;
}

ostream& operator<<(ostream& os, const vector<string>& values)
{
  copy(values.begin(), values.end(), ostream_iterator<string>{os, "\n"});
  return os;
}

void Policlinic::addSpecialists(const string& s)
{
  istringstream is(s);
  is >> m_personnel->specialists;
}

void Policlinic::addTherapists(const string& s)
{
  istringstream is(s);
  is >> m_personnel->therapists;
}

void Policlinic::printPersonnel(spType stype)
{
  switch(stype)
  {
  case spType::SP:
    cout << "Специалисты:\n"
         << m_personnel->specialists;
    break;

  case spType::TH:
    cout << "Терапевты:\n" 
         << m_personnel->therapists;
    break;

  default:
    cout << "[Весь персонал]\n";
         printPersonnel(spType::SP);
         printPersonnel(spType::TH);
    break;
  }
}

int main()
{
  SetConsoleCP(1251);
  SetConsoleOutputCP(1251);
  setlocale(LC_ALL, "ru");

  Policlinic ply;

  // Для простоты
  string value;
  
  cout << "Введите врачей специалистов через пробел \n$: ";
  getline(cin, value);
  ply.addSpecialists(value);
  
  cout << "\nВведите врачей терапевтов через пробел\n$: ";
  getline(cin, value);
  ply.addTherapists(value);
 
  ply.printPersonnel(spType::ALL);

  system("pause");
}

#include<iterator>
#include<iostream>
#include<algorithm>
#include<memory>
using namespace std;

class Decmal
{
public:
  explicit Decmal(size_t size = 5);
  Decmal(const Decmal&);
  size_t get_size() const
  {
    return size;
  }
  // ...
private:
  size_t size;
  unique_ptr<char> data;
  // ...
private:
  void resize(size_t sz);
  friend istream& operator>>(istream& is, Decmal& dec);
  friend ostream& operator<<(ostream& os, const Decmal& dec);
};

Decmal::Decmal(size_t size) : size{ size }, data(new char[size])
{
  fill_n(data.get(), size, '0');
}

Decmal::Decmal(const Decmal& rh)
{
  size = rh.size;
  data.reset(new char[size]);
  copy_n(rh.data.get(), size, data.get());
}

void Decmal::resize(size_t new_size)
{
  if(size < new_size)
  {
    data.reset(new char[new_size]);
    size = new_size;
  }
}

istream& operator>>(istream& is, Decmal& dec)
{
  is.putback(is.get());
  size_t new_size = static_cast<size_t>(is.rdbuf()->in_avail() - 1);

  dec.resize(new_size);

  copy_n(istream_iterator<char>{is}, dec.size, dec.data.get());
  return is;
}

ostream& operator<<(ostream& os, const Decmal& dec)
{
  copy_n(dec.data.get(), dec.size, ostream_iterator<char>{os});
  return os;
}

int main()
{
  Decmal x;

  cin >> x;

  cout << x.get_size() << " " << x << endl;

  system("pause");
}

#include<iterator>
#include<iostream>
#include<algorithm>

using namespace std;

class Decmal
{
public:
  explicit Decmal(size_t size = 5);
  Decmal(const Decmal&);
  ~Decmal(){ delete[] data; }

  size_t get_size() const
  {
    return size;
  }
  // ...
private:
  size_t size;
  unsigned char* data = nullptr;
  // ...
private:
  void resize(size_t sz);
  friend istream& operator>>(istream& is, Decmal& dec);
  friend ostream& operator<<(ostream& os, const Decmal& dec);
};

Decmal::Decmal(size_t size) : size{ size }, data(new unsigned char[size])
{
  fill_n(data, size, '0');
}

Decmal::Decmal(const Decmal& rh)
{
  size = rh.size;
  delete[] data;

  data = new unsigned char[size];

  copy_n(rh.data, size, data);
}

void Decmal::resize(size_t new_size)
{
  if(size < new_size)
  {
    delete[] data;
    data = new unsigned char[new_size];
    size = new_size;
  }
}

istream& operator>>(istream& is, Decmal& dec)
{
  char c = 0;
  size_t sz = 0;

  while(is.read(&c, 1) && c != '\n') // \n == 10 \r == 13
  {
    if(sz == dec.size)
    {
      unsigned char* tmp = new unsigned char[sz + 1];
      copy_n(dec.data, dec.size, tmp);
      dec.resize(sz + 1);
      copy_n(tmp, dec.size, dec.data);
      delete[] tmp;
    }
    dec.data[sz] = c;
    ++sz;
  }

  return is;
}

ostream & operator<<(ostream& os, const Decmal& dec)
{
  copy_n(dec.data, dec.size, ostream_iterator<char>{os});
  return os;
}

int main()
{
  Decmal x;

  cin >> x;

  cout << x.get_size() << " " << x << "\n";

  Decmal y = x;

  cout << y << endl;

  system("pause");
}