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
}