////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <typeinfo>

////////////////////////////////////////////////////////////////////////////////
//class t_errors

class t_errors
{
 public:
  virtual void add(int errCode)=0;
    void print()
    {
        std::cout << (void*)this << " : " << typeid(*this).name() << "\n";
    }
};

////////////////////////////////////////////////////////////////////////////////
//class t_context

class t_context
{
 private:
  t_context(const t_context&)=delete;
  t_context& operator = (const t_context&)=delete;

 public:
  class tag_errs_without_limits:public t_errors
  {
   public:
    explicit tag_errs_without_limits(t_context* const pCtx):m_pCtx(pCtx)
    {
        std::cout << __PRETTY_FUNCTION__ << "\n";
        print();
    }

    tag_errs_without_limits(const tag_errs_without_limits &_):m_pCtx(_.m_pCtx)
    {
        std::cout << __PRETTY_FUNCTION__ << "\n";
        print();
    }

    ~tag_errs_without_limits()
    {
        std::cout << __PRETTY_FUNCTION__ << "\n";
        print();
    }

    virtual void add(int errCode)override
    {
          m_pCtx->helper__add_error(errCode);
          std::cout << __PRETTY_FUNCTION__ << "\n";
          print();
    }

   private:
    t_context* m_pCtx;
  };//class tag_errs_without_limits

 public:
  class tag_errs_with_limits:public t_errors
  {
   public:
    explicit tag_errs_with_limits(t_context* const pCtx):m_pCtx(pCtx)
    {
        std::cout << __PRETTY_FUNCTION__ << "\n";
        print();
    }

    tag_errs_with_limits(const tag_errs_with_limits &_):m_pCtx(_.m_pCtx)
    {
        std::cout << __PRETTY_FUNCTION__ << "\n";
        print();
    }

    ~tag_errs_with_limits()
    {
        std::cout << __PRETTY_FUNCTION__ << "\n";
        print();
    }

    virtual void add(int errCode)override
    {
          /*check limits*/
          m_pCtx->helper__add_error(errCode);
          std::cout << __PRETTY_FUNCTION__ << "\n";
          print();
    }

   private:
    t_context* m_pCtx;
  };//class tag_errs_with_limits

 public:
  t_context()
  {}

  tag_errs_without_limits get_errors_without_limits()
  {
    std::cout << __PRETTY_FUNCTION__ << "\n";
    return tag_errs_without_limits(this);
  }//get_errors_without_limits

  tag_errs_with_limits get_errors_with_limits()
  {
    std::cout << __PRETTY_FUNCTION__ << "\n";
    return tag_errs_with_limits(this);
  }//get_errors_with_limits

 private:
  void helper__add_error(int const errCode)
  {
   std::cout<<"helper__add_error: "<<errCode<<"!\n";
  }
};

////////////////////////////////////////////////////////////////////////////////

//add_error - может быть виртуальным методом некоторого класса

void add_error(t_errors&& errs,int const errCode)
{
    std::cout << __PRETTY_FUNCTION__ << "\n";
    errs.print();

    errs.add(errCode);

}//add_error

////////////////////////////////////////////////////////////////////////////////

int main()
{
 t_context ctx;

 add_error(ctx.get_errors_without_limits(),1);
 std::cout << "\n";
 add_error(ctx.get_errors_with_limits(),2);

 return 0;
}//main
////////////////////////////////////////////////////////////////////////////////