C ++替换：用v.atx替换v [x]的每次出现

如何解决C ++替换：用v.atx替换v [x]的每次出现

在C ++中，对于向量v，v.at(x)的行为类似于v[x]，不同之处在于，如果访问不存在的元素，它将抛出超出范围的错误。

理想情况下，我想始终使用v.at(x)，但是写起来不如v[x]方便。有没有办法让v[x]表现得像v.at(x)，也许可以使用类似#define的东西？

如果没有，是否有更好的解决方案来始终抛出越界错误？

解决方法

您可以考虑按如下所示在新继承中重载该方法

#include <iostream>
#include <vector>

template< class T,class allocator =  std::allocator<T>>
struct Vector : std::vector<T,allocator>{
    using std::vector<T,allocator>::vector;

    const T& operator[](size_t i)const{
        return this -> at(i);
    }

    T& operator[](size_t i){
        return this -> at(i);
    }
};

template< class T>
Vector(size_t,T ) -> Vector<T>;//if u want to use c++17 deduction guides

int main()
{
    std::vector<int> vec1(4,1);
    std::cout << vec1[4];

    Vector vec2(4,1);
    std::cout << vec2[4];

}

,

您可以将带有操作符[]的代理对象与调用方法at（）的对象一起使用。当然，这并不是您想要的，但是语法相似：您必须写at（v）[x]来代替v [x]。

概念证明：

#include <iostream>
#include <vector>


template<class T>
class AtProxy
{
  public:
    AtProxy(const AtProxy<T>& proxy) : m_obj{proxy.m_obj} {}
    AtProxy(T& obj) : m_obj{obj} {}
    typename T::reference operator [](size_t index)
    {
      return m_obj.at(index);
    }
  private:
    T& m_obj;
};


template<class T>
AtProxy<T> at(T& v)
{
  return AtProxy<T>(v);
}


int main()
{
  try
  {
    std::vector<int> vec = {1,2,3,4,5};

    for(size_t i = 0; i < 5; i++)   
    {
      std::cout << i << std::endl;
      at(vec)[i] = at(vec)[i + 1] + 1;
    }   
  }
  catch(std::exception& e)
  {
    std::cout << "exception: " << e.what() << std::endl;
  }
   
  std::cout << "ok" << std::endl;
  return 0;
}