Вы сталкивались с какой-либо причиной трех уровней косвенности?

Question

Просто пролистав одну из моих любимых книг («Ошибка» Эллен Уллман), есть небольшой кусочек, когда один программист сталкивается с другим на трех уровнях косвенности:

***object_array = ***winarray;

Я понял идею двойного косвенного обращения - способ передачи указателя в функцию и предоставления ему возможности указывать на объект, созданный в функции.

Но сталкивались ли вы с какой-либо причиной использования трех (или более) уровней косвенности?

Answer 1

Sure
4-х мерные массивы.
Это не займет слишком много для приложения для такого массива. Скажем, какая-то таблица поиска. У меня были таблицы поиска 8 и более измерений.

Answer 2

Как сказал Дэвид Уил: «Любая проблема в информатике может быть решена с помощью другого уровня косвенности». Вы почти наверняка использовали три слоя косвенности с такой строкой:

int x = 3;

В конце концов, чип косвенно обращается к памяти через два уровня кэш-памяти L1 и L2. А ОС косвенно обращается к памяти через страницы виртуальной памяти. А ваш компилятор C # косвенно обращается к памяти через объекты на виртуальной машине. Несомненно, это не идет с длинной строкой звездочек, но это потому, что все эти косвенные ссылки абстрагируются от вещей, таких как машина, ОС или компилятор.

Answer 3

Нет, я на самом деле никогда не видел и не использовал его (насколько я помню, и, по крайней мере, без разумных typedefs, чтобы сделать его менее пугающим), но я могу придумать пример того, что может быть [сомнительно] действительное использование:

struct Foo{
    struct greater{
        bool operator()(Foo const *a, Foo const *b) const{
            return a->place > b->place ||
                   a->place == b->place && a->holder > b->holder;
        }
    };

    int place;
    int holder;
};

template<typename T, typename Comparer>
void Sort(T const *unorderedList, int count, T const ***orderedList, Comparer &cmp);

void UseOrderedList(Foo const **orderedList, int count);

int main(){
    Foo list[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
    Foo const **orderedList;

    Sort(list, sizeof list / sizeof *list, &orderedList, Foo::greater());
    UseOrderedList(orderedList, sizeof list / sizeof *list);
    delete[] orderedList;
    return 0;
}

void UseOrderedList(Foo const **orderedList, int count){/*...*/}

template<typename T, typename Comparer>
void Sort(T const *unorderedList, int count, T const ***orderedList, Comparer &cmp){
    /*
     * The result array stores pointers to the items in the original array.
     * This way, the original array is unmodified, and the result array
     * doesn't create duplicate items.  This makes sense if the objects
     * are large and copying them would be slow (another argument against
     * in-place sorting), or if duplicating them violates some design
     * principle.
     */
    *orderedList = new const T*[count];

    for(int i = 0; i < count; i++)
        (*orderedList)[i] = unorderedList + i;

    std::sort(*orderedList, &(*orderedList)[count], cmp);
}

Я бы на самом деле не делал то, что сделал здесь. Это просто пример того, как вы можете получить три уровня указателя. Но я не могу представить, чтобы вы часто сталкивались с подобным сценарием.

Answer 4

Возможно, вы сейчас работаете на 3 или более уровнях. Может быть jQuery на javascript в браузере, работающем в Windows на Mac (или в виртуальной машине) через удаленный доступ, работающий в ....

Или, с другой точки зрения, более близкой к контексту вашего вопроса, 3 уровня - это самый распространенный артефакт, который у нас есть.

Что означает указатель на элемент управления в контейнере в окне?