您是否遇到过三级间接的任何原因？

Question

翻阅我最喜欢的一本书（Ellen Ullman 的《The Bug》），有一小段内容，一个程序员在三个间接级别上与另一个程序员对峙：

***object_array = ***winarray;

我得到了双重间接的想法 - 一种将指针传递到函数的方法，并且允许它指向函数内创建的对象。

但是您是否遇到过使用三层（或更多）间接层的任何理由？

Answer 1

当然
4 维数组。
对于这样的数组的应用程序来说也不需要太多。 说某种查找表。 我有 8 个或更多维度的查找表。

Answer 2

正如 David Wheele 所说：“计算机科学中的任何问题都可以通过另一层间接解决。” 几乎可以肯定，您已经使用了这样的一行的三层间接：

int x = 3;

毕竟，芯片是通过两层 L1 和 L2 缓存来间接访问内存的。 操作系统通过虚拟内存页间接访问内存。 您的 C# 编译器通过虚拟机中的对象间接访问内存。 当然，它没有一长串星号，但那是因为所有这些间接都是用机器、操作系统或编译器等事物抽象出来的。

Answer 3

您现在可能正在运行 3 个或更多级别。 可能是在 Mac（或 VM）上的 Windows 中运行的浏览器中的 javascript 上的 jQuery，通过在...中运行的远程访问。

或者，从更接近您的问题上下文的另一个角度来看，3 个级别是我们最常见的工件。

什么是指向窗口容器中控件的指针？

Answer 4

不，我从未真正见过或使用过它（据我所知，至少在没有合理的 typedef 来使其不那么令人困惑的情况下），但我可以设计一个可能是[可疑]有效使用的示例：

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

我实际上不会做我在这里所做的事情。 这只是一个如何最终获得三个指针级别的示例。 不过，我无法想象您经常遇到这种情况。