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

Question

sé la regla de dedo para leer las declaraciones de derecha a izquierda y yo 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 un puntero const a una MyStructure (mutable) (en C++).

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

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

Answer 1

Su colega está equivocado. Eso es un puntero (no const) a un puntero (no const) a una estructura MyStructure. En C y C++.

Answer 2

En tales casos, el cdecl herramienta (o C++ decl) puede ser servicial:

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

Answer 3

su colega está mal, y que es el mismo para C y C++. Pruebe 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 

GCC 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 

Answer 4

Has acertado en tu interpretación. Aquí hay otra manera 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 puntero a uno con el calificador const. La regla de derecha a izquierda se puede usar para descifrar las declaraciones (al menos en C++; no soy experto en C).

Answer 5

Usted tiene razón.

Another answer ya señalado al "Clockwise Spiral Rule". Me gustó mucho ese, aunque un poco elaborado.

Answer 6

Como corolario de los otros comentarios, no coloque 'const' primero. Realmente pertenece después del tipo. Eso habría aclarado el significado de inmediato, simplemente leyó RTL como de costumbre:

MyStructure const** ppMyStruct; 

Answer 7

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 
}