diferencia - ¿Qué significa const pointer-to-puntero en C y en C++?

const in c

Question

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

const MyStructure** ppMyStruct;

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

Hubiera pensado que significaba "ppMyStruct es un puntero a un puntero a una estructura de const ". 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

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

MyStructure const** ppMyStruct;

Answer 2

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

Answer 3

Tu colega está equivocado, y es lo 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 proporciona 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

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

Answer 5

Tuviste 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 puntero a puntero con un clasificador const. La regla de derecha a izquierda se puede usar para descifrar las declaraciones (al menos en C ++; no soy experto en C).

Answer 6

Tienes 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.

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
}