¿Qué significa un puntero a puntero const en C y en C++?

Conozco la regla empírica para leer las declaraciones de derecha a izquierda y estaba bastante seguro de que sabía lo que estaba pasando hasta que un colega me dijo que:

const MyStructure** ppMyStruct;

significa “ppMyStruct es un puntero a una const puntero a una MyStructure (mutable)” (en C++).

Hubiera pensado que significaba “ppMyStruct es un puntero a un puntero a una const MyStructure“. Busqué una respuesta en la especificación de C++, pero aparentemente no soy muy bueno en eso…

¿Qué significa en C++ y significa lo mismo en C?

Tu colega está equivocado. Es un puntero (no constante) a un puntero (no constante) a una MiEstructura constante. Tanto en C como en C++.

En tales casos, la herramienta cdecl (o c++decl) puede ser útil:

     [flolo@titan ~]$ cdecl explain "const struct s** ppMyStruct"
     declare ppMyStruct as pointer to pointer to const struct s

Tenías razón en tu interpretación. Aquí hay otra forma de verlo:

const MyStructure *      *ppMyStruct;        // ptr --> ptr --> const MyStructure
      MyStructure *const *ppMyStruct;        // ptr --> const ptr --> MyStructure
      MyStructure *      *const ppMyStruct;  // const ptr --> ptr --> MyStructure

Estas son todas las alternativas de un puntero a puntero con un calificador const. La regla de derecha a izquierda se puede usar para descifrar las declaraciones (al menos en C++; no soy un experto en C).

Su colega está equivocado y es lo mismo para C y C++. Prueba lo siguiente:

typedef struct foo_t {
    int i;
} foo_t;

int main()
{
    foo_t f = {123};
    const foo_t *p = &f;
    const foo_t **pp = &p;
    printf("f.i = %d\n", (*pp)->i);
    (*pp)->i = 888; // error
    p->i = 999;     // error
}

Visual C++ 2008 da los siguientes errores para las dos últimas líneas:

error C2166: l-value specifies const object
error C2166: l-value specifies const object

CCG 4 dice:

error: assignment of read-only location '**pp'
error: assignment of read-only location '*p'

g ++ 4 dice:

error: assignment of data-member 'foo_t::i' in read-only structure
error: assignment of data-member 'foo_t::i' in read-only structure

Tú tienen razón.

Otra respuesta ya apuntaba a la “Regla espiral en el sentido de las agujas del reloj“. Me gustó mucho ese, aunque un poco elaborado.

Como corolario de los otros comentarios, no ponga ‘const’ primero. Realmente pertenece después del tipo. Eso habría aclarado el significado de inmediato, solo léalo RTL como de costumbre:

MyStructure const** ppMyStruct;

void Foo( int       *       ptr,
          int const *       ptrToConst,
          int       * const constPtr,
          int const * const constPtrToConst )
{
    *ptr = 0; // OK: modifies the pointee
    ptr  = 0; // OK: modifies the pointer

    *ptrToConst = 0; // Error! Cannot modify the pointee
    ptrToConst  = 0; // OK: modifies the pointer

    *constPtr = 0; // OK: modifies the pointee
    constPtr  = 0; // Error! Cannot modify the pointer

    *constPtrToConst = 0; // Error! Cannot modify the pointee
    constPtrToConst  = 0; // Error! Cannot modify the pointer
}