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

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

class t_errors
{
 public:
  virtual void add(int errCode)=0;
};

////////////////////////////////////////////////////////////////////////////////
//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){;}

    virtual void add(int errCode)override {m_pCtx->helper__add_error(errCode);}

   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){;}

    virtual void add(int errCode)override {/*check limits*/; m_pCtx->helper__add_error(errCode);}

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

 public:
  t_context()
  {}

  tag_errs_without_limits get_errors_without_limits()
  {
   return tag_errs_without_limits(this);
  }//get_errors_without_limits

  tag_errs_with_limits get_errors_with_limits()
  {
   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)
{
 errs.add(errCode);
}//add_error

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

int main()
{
 t_context ctx;

 add_error(ctx.get_errors_without_limits(),1);
 add_error(ctx.get_errors_with_limits(),2);

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

//...
  virtual void GetData_AddErrorRecord__CantGetData
                               (typename call_ctx_type::errors_type& Errors,
                                const TBaseColumnsInfoImpl*          pColumnsInfo,
                                const DBBINDING&                     Binding,
                                const void*                          pData,
                                HRESULT                              get_data_hr)=0;
//...
template<class TStorageTraits>
HRESULT TMemRowsetStorageROImpl<TStorageTraits>::GetData
                                    (call_ctx_type&                    CallCtx,
                                     TRowBmk                     const Bmk,
                                     const TBindingArray*        const pBindingArray,
                                     const TBaseColumnsInfoImpl* const pColumnsInfo,
                                     void*                       const pData)
{
 //....
     if(get_data_hr!=S_OK)
     {
      this->GetData_AddErrorRecord__CantGetData
       (CallCtx.ErrorsWithLimit(), //<---------------- Вот проблемная точка
        pColumnsInfo,
        *pBinding,
        pData,
        get_data_hr); //no throw

      ++cntErrors;
     }//if
 //....
}//GetData
//...

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){;}

    virtual void add(int errCode)override {m_pCtx->helper__add_error(errCode);}

   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){;}

    virtual void add(int errCode)override {/*check limits*/; m_pCtx->helper__add_error(errCode);}

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

 public:
  t_context()
   :m_errs_without_limits(this)
   ,m_errs_with_limits(this)
  {}

  tag_errs_without_limits& get_errors_without_limits()
  {
   return m_errs_without_limits;
  }//get_errors_without_limits

  tag_errs_with_limits& get_errors_with_limits()
  {
   return m_errs_with_limits;
  }//get_errors_with_limits

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

 private:
  tag_errs_without_limits m_errs_without_limits;
  tag_errs_with_limits m_errs_with_limits;
};//class t_context

////////////////////////////////////////////////////////////////////////////////
#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
////////////////////////////////////////////////////////////////////////////////