Написание нижестоящей функции, не являющейся членом

Question

Я предполагаю, что это просто недопустимо в C ++, но я решил спросить, учитывая структуру, которой я не владею:

struct foo {
    int x;
    int y;
    int z;
};

Я хочу написать неоператор нижестоящего элемента для него:

int& operator [](foo& lhs, const std::size_t rhs) {
    switch(rhs) {
    case 0U:
        return lhs.x;
    case 1U:
        return lhs.y;
    case 2U:
        return lhs.z;
    default:
        return *(&(lhs.z) + rhs - 2U);
    }
}

Я получаю эту ошибку :

ошибка: int& operator[](foo&, std::size_t) должна быть нестатической функцией-членом

Answer 1

struct foo {
    int x;
    int y;
    int z;

  int& operator [](const std::size_t rhs) & {
    switch(rhs) {
      case 0U:
        return this->x;
      case 1U:
        return this->y;
      case 2U:
        return this->z;
      default:
        return *(&(this->z) + rhs - 2U);
    }
  }
};

не все операторы могут быть перегружены как свободные функции.

Не стандарт, но четко прописано в cppreference , операторы [], =, -> и () должны быть нестатическими функциями-членами.

Если вы можете сделать wrap(f)[2], вы можете заставить его работать.Но на экземпляре foo невозможно заставить его работать напрямую.

template<class T>
struct index_wrap_t {
  T t;
  template<class Rhs>
  decltype(auto) operator[](Rhs&& rhs)& {
    return operator_index( *this, std::forward<Rhs>(rhs) );
  }
  template<class Rhs>
  decltype(auto) operator[](Rhs&& rhs)&& {
    return operator_index( std::move(*this), std::forward<Rhs>(rhs) );
  }
  template<class Rhs>
  decltype(auto) operator[](Rhs&& rhs) const& {
    return operator_index( *this, std::forward<Rhs>(rhs) );
  }
  template<class Rhs>
  decltype(auto) operator[](Rhs&& rhs) const&& {
    return operator_index( std::move(*this), std::forward<Rhs>(rhs) );
  }
};

template<class T>
index_wrap_t<T> index( T&& t ) { return {std::forward<T>(t)}; }

, тогда вы можете сделать это:

int& operator_index( foo& lhs, std::size_t rhs ) {
  // your body goes here
}
foo f;
index(f)[1] = 2;

, и это сработает.

index_wrap_t переадресовывает [] на бесплатный звонок operator_index, который выполняет ADL.

Answer 2

Вы можете иметь класс и функцию-оболочку:

struct foo_wrapper {
    foo &ref;

    foo_wrapper( foo &f ) : ref( f ) {}
    int &operator[]( std::size_t rhs ) {
       switch(rhs) {
       case 0U:
           return ref.x;
       case 1U:
           return ref.y;
       case 2U:
           return ref.z;
       default:
           return *(&(ref.z) + rhs - 2U);
        }
    }    
};

foo_wrapper wrap( foo &ff )
{
    return foo_wrapper( ff );
}

foo f;
wrap( f )[1] = 123;

Живой пример Вам может понадобиться эта вспомогательная функция, так как она прямо пишет:

foo_wrapper( f )[2] = 0; 

приведет к ошибке компиляции (повторное объявление f)