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使它不那么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);
}

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

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

4 个答案: