Имеется код на подобии такого:

int plain_old_array[4];

3[plain_old_array] = 100;
int last_value = 3[plain_old_array];

int index = 2;
index[plain_old_array] = 546;
int value = index[plain_old_array];

В ходе рефакторинга старого кода осуществляю замену C-style массивов на ::std::array, при которой такие конструкции, естественно, перестают работать. Причем их достаточно большое количество, некоторые даже сделаны в виде макросов.
Я что-то не могу установить для себя, является ли такой вызов оператора индексирования какой-то особой хитростью, на которую автор пошел намеренно, или это просто кривой код. Кто-нибудь сталкивался с подобным?

Здравствуйте, VTT, Вы писали:

VTT>или это просто кривой код

Именно.

VTT>автор пошел намеренно

Вероятно, что намеренно. С мотивацией на уровне "смотрите как я умею!" Но продолжать его дело не стоит.

Здравствуйте, VTT, Вы писали:

VTT>Я что-то не могу установить для себя, является ли такой вызов оператора индексирования какой-то особой хитростью, на которую автор пошел намеренно, или это просто кривой код. Кто-нибудь сталкивался с подобным?

plain_old_array[3] ~=~ *(plain_old_array + 3) ~=~ *(3 + plain_old_array) ~=~ 3[plain_old_array]

~=~ тут -- эквивалентность выражений.

Здравствуйте, MasterZiv, Вы писали:

MZ>

MZ>plain_old_array[3] ~=~ *(plain_old_array + 3) ~=~ *(3 + plain_old_array) ~=~ 3[plain_old_array]
MZ>

Думаю, что топикстартеру это известно.
Вопросов только два:
— нафига
— как починить

К сожалению, предложение разрешить делать operator[] внешним — хорошо, если в 17 стандарте появится, и то не факт.
То есть, сделать приставку к std::array не выйдет — ни снаружи, ни внутри.

Поэтому починку можно свести лишь к одному: кровавый рефакторинг и исправление во всех местах, где сломалась компиляция.

Здравствуйте, Кодт, Вы писали:

К>Вопросов только два:
К>- нафига

А вот. И вообще, не "нафига", а "птамушта"

К>- как починить

А сделать оператор приведения к ссылке на массив, не ?

Типа того:

#include <iostream>
#include <vector>

template <typename T>
class array_t
{
  std::vector< T > a;

public:
  array_t(){}
  array_t( size_t size ) : a(size) {}

  size_t size() const
  {
    return a.size();
  }

  T& operator [] ( size_t idx )
  {
    return a[idx];
  }

  const T& operator [] ( size_t idx ) const
  {
    return a[idx];
  }

  operator const T* () const
  {
    return &(a[0]);
  }
};



int main()
{
  array_t< int > a(10);

  for( unsigned i = 0; i < a.size(); ++i )
    a[i] = i + 1;

  for( unsigned i = 0; i < a.size(); ++i )
    std::cout << "a[" << i << "] = " << i[a] << std::endl;

  return 0;
}

Здравствуйте, MasterZiv, Вы писали:

MZ>А сделать оператор приведения к ссылке на массив, не ?

Прикручивать к stl костыль чтоб сэкономить немного на рефакторинге — сомнительная идея.
Еще при возврате к указателям одна из главных плюшек ::std::array — проверка на выход за пределы — теряется.

Здравствуйте, VTT!

Кто-нибудь сталкивался с подобным?

===

Я писал подобное, двухуровневое даже. Считаю, что вполне к месту.

http://old-dos.ru/screens/3785/C_ClockDevelopmentArrays.png

http://old-dos.ru/files/file_3785.html

Здравствуйте, SergeCpp, Вы писали:

SC>Я писал подобное, двухуровневое даже. Считаю, что вполне к месту.

И что побудило вас писать в таком стиле? Хоть какая-то польза была?

SC>писал

Теперь, значит, не пишите?