calificador const para los punteros a punteros

Question

estoy teniendo un problema poco deducir lo que se const, cuando se aplica a los punteros a punteros, etc. es decir, lo que es const cuando se tiene

const Foo **foo; 

¿Puedo aquí el cambio algo en ** foo? como en foo[0]->bar = 12;

¿Qué hay de:

const Foo ***foo; 
Foo **const foo; 

Answer 1

Usted podría utilizar cdecl a entender lo que significa una declaración C.

const int **foo; 
declare foo as pointer to pointer to const int 

por lo que puede cambiar los punteros, pero no el valor que están apuntando.

int * const * const foo; 
declare foo as const pointer to const pointer to int 

esto, en cambio, es un puntero cosnt, que apunta a un puntero constante, a un int no constante: no se puede cambiar el valor en punta, pero se puede cambiar.

---

C utiliza el Clockwise/Spiral Rule, en un caso en el que sólo tiene modificadores en el lado izquierdo de la variable (de foo) que lee cosas pasando de derecha a izquierda:

int(5) *(4) const(3) *(2) const(1) foo; 

foo es una constante (1) puntero (2) a constante (3) puntero (4) a un entero (5).

int(6) const(5) *(4) const(3) *(2) const(1) foo; 
const(6) int(5) *(4) const(3) *(2) const(1) foo; // [same as above] 

En este caso foo es una constante (1) puntero (2) a constante (3) puntero (4) a una (5) número entero constante (6) [oa un número entero (5) que está constante (6)].

Answer 2

const Foo * * foo (o Foo const * * foo) es un puntero a un puntero a un const Foo.

Foo * const * foo es un puntero a un puntero const a un Foo.

Foo * * const foo es un puntero de const a un puntero a un Foo.

Answer 3

En const Foo **foo, es el objeto real Foo que es const. Entonces puede cambiar foo, y puede cambiar *foo, pero no puede cambiar **foo.

Para const Foo ***foo, puede cambiar foo, *foo y **foo, pero no ***foo.

Para Foo **const foo, puede cambiar *foo y **foo, pero no foo sí.

Answer 4

Lea los tipos de adentro hacia afuera. A partir de foo, const Foo **foo; lee * (puntero) a * (puntero) a const Foo (un objeto Foo que no puede modificar). Foo **const foo; lee const (no modificable) * (puntero) a * (puntero) a Foo (un objeto Foo).

Answer 5

El const se aplica a la expresión **foo; por lo tanto, foo y *foo son modificables, pero **foo no.

Algunos otros ejemplos:

const Foo * const *foo; // foo is writable, *foo and **foo are not 
Foo * const * foo;  // foo and **foo are writable, *foo is not 
Foo * const * const foo; // **foo is writable, foo and *foo are not 
const Foo * const * const foo; // none of the expressions are writable 

Answer 6

La manera más fácil de escribir estas expresiones de tipo, creo, es tener la const se aplican siempre a la izquierda. El que dio también se puede escribir:

Foo const**foo; 

Aquí el const sólo se aplica a lo que queda, por lo tanto Foo.

Foo *const* foo; 

Aquí a la izquierda es Foo*

Foo const*const* foo; 

es entonces ((Foo const)*const)*.

Cuando a su vez desee leer dicha expresión, intercambie el const y el tipo simple si es necesario para tener el const a la derecha.