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

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

***object_array = ***winarray;

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

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

11.12.2008 01:40:02
4 ОТВЕТА
РЕШЕНИЕ

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

4
11.12.2008 01:47:14

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

int x = 3;

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

3
11.12.2008 02:14:13

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

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

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

2
11.12.2008 02:33:45

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

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

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

2
29.03.2011 04:02:55