c++ - 在指向数组转换的指针的上下文中，有人可以解释为什么这些转换是合法的还是非法的？

Question

复习一下(多维)数组/指针转换的知识，下面两条规则可以解释一些非法转换:

1. T[M][N] 衰减为 T(*)[N]，但不会衰减为 T** (如 this SO entry 中所述)
2. 没有从 T** 到 const T** 的隐式转换(如 the C++ faq 中所述)

所以这里写了一些测试代码来尝试涵盖不同的情况。我们无法解释的 3 个案例用 P1、P2 和 P3 进行了注释。

int main() {
    {
        int arrayOfInt[3] = {0, 1, 2};
        int * toPtr{nullptr};
        int ** toPtrPtr{nullptr};
        const int ** toPtrPtrConst{nullptr};


        toPtr = arrayOfInt;

        //toPtrPtr = &arrayOfInt; //KO, I assume because of 1.
        //toPtrPtr = static_cast<int**>(&arrayOfInt); //KO, same as above
        toPtrPtr = reinterpret_cast<int**>(&arrayOfInt);
        toPtrPtr = (int**)&arrayOfInt;

        //toPtrPtrConst = &arrayOfInt; //KO, still 1.
        //toPtrPtrConst = static_cast<const int**>(&arrayOfInt); //KO, still 1.
        toPtrPtrConst = reinterpret_cast<const int**>(&arrayOfInt); // (P1)
            // it is supposed to be allowed to cast int** to const int* const*
            // not const int**
            // Why is it working without requiring a const_cast
            // to cast away the const qualifier?
        toPtrPtrConst = (const int**)&arrayOfInt;

        //toPtrPtrConst = toPtrPtr; //KO, because of 2.
        //toPtrPtrConst = reinterpret_cast<const int**>(toPtrPtr); //KO because of 2.
            // so why is P1 allowed?
    }

    {
        const int arrayOfConstInt[3] = {0, 1, 2};
        const int * toPtrConst{nullptr};
        const int ** toPtrPtrConst{nullptr};
        int * const * toPtrConstPtr{nullptr};

        toPtrConst = arrayOfConstInt;

        //toPtrPtrConst = &arrayOfConstInt; //KO, I assume because of 1.
        //toPtrPtrConst = static_cast<const int**>(&arrayOfConstInt); //KO, same as above
        //toPtrPtrConst = reinterpret_cast<const int**>(&arrayOfConstInt); // (P2) 
            // Compiler error "casts away qualifiers",
            // but which qualifier(s) would that cast away?
        toPtrPtrConst = (const int**)&arrayOfConstInt;

        //toPtrConstPtr = &arrayOfConstInt; //KO, I assume because of 1.
        //toPtrConstPtr = static_cast<int * const *>(&arrayOfConstInt); //KO, same as above
        toPtrConstPtr = reinterpret_cast<int * const *>(&arrayOfConstInt); // (P3) 
            // This one actually drops the const qualifier on the integer,
            // but nevertheless it compiles
        toPtrConstPtr = (int * const *)&arrayOfConstInt;

        toPtrConstPtr = reinterpret_cast<int * const *>(&toPtrConst); // KO
            // because it casts away const qualifier
            // so why is P3 allowed?
    }
}

在ideone里面:http://ideone.com/JzWmAJ

• 为什么 P1 允许，但它似乎违反了 2.？
• P2 丢弃的限定符是什么？
• 为什么 P3 在实际丢弃 const 限定符时允许？

Answer 1

1. 显式类型转换(又名“强制转换”)不违反隐式类型转换规则，因为隐式类型转换规则并不适用于显式类型转换，这不足为奇。
2. const int (*)[3] 是一种指向常量对象的指针(其中“对象”是 int[3])，而const int** 是一种指向非常量某物的指针(其中“某物”是指向 const int 的指针)。 pointer-to-constant-something 中的常量被剥离，这是不允许的。
3. 没有去除限定词。 toPtrConstPtr 是一个指向常量的指针(其中 something 是 int *)并且 &arrayOfConstInt 是一个指向常量的指针(其中某物是 int[3])。

需要注意的是，这完全是语言律师 Material 。任何普通程序员都不应在代码附近的任何地方允许任何这些强制转换。