2012-08-23 21 views
5

He visto const usado dos veces antes en la declaración de una matriz static y ahora que estoy creando mi propia matriz estática me pregunto por qué se necesitaría const dos veces en algunas situaciones.Const de C++ dos veces en la declaración de matriz estática

¿Tiene una variedad de punteros que hacen la diferencia?

a. static const TYPE name[5]; 
b. static const TYPE const name[5]; 

c. static const TYPE* name[5]; 
d. static const TYPE* const name[5]; 

Mi entendimiento es que b. no es válido, pero si se utiliza el doble const es válida, ¿cuál es su propósito?

Respuesta

12

const TYPE * x;

Significa que lo que señala x es const.

TIPO * const x;

Significa que el puntero x es const.

2 La combinación de la que se obtiene:

const * const x TIPO;

Lo que significa que el puntero y el objeto señalado son ambos const.

+0

Gracias por la pronta respuesta. Voy a marcar esto correcto mañana. – Jim

0

En el primer bloque de código tiene un duplicado redundante const en la segunda línea, que no tiene ningún efecto. (De hecho, los buenos compiladores te advertirán sobre esto.) Estás declarando una matriz de 5 const TYPE s, eso es todo.

El segundo bloque de código tiene dos escenarios diferentes: La primera línea hace una matriz de cinco mutables punteros a const TYPE s, mientras que el segundo hace una matriz de cinco constantes punteros a const TYPE s.

Tenga en cuenta que debe inicializar una matriz de constantes: dado que no puede cambiar los valores más adelante, no tiene sentido definirlos sin inicializar.

+0

En realidad, puedes lanzar tantos 'const's como quieras. Son idempotentes. – bitmask

+0

@bitmask: Oh, bien, corregido. Sin embargo, obtendrás una advertencia del compilador de compiladores sensatos :-) ¡Gracias! –

+0

Ooops, podría haber mezclado C y C++ aquí. Mi error. – bitmask

1

Puede aplicar cualquier calificador cv (const o volatile) a cualquier tipo, incluidos los tipos calificados para cv, pero no en la misma declaración. Sin embargo, se unen con más fuerza que cualquier operador, en términos de precedencia y se pueden aplicar a ambos lados del tipo cualificado:

// Let T by any type: 
T const tr; 
const T tl; 
const T const tlr; // only in C 
const const const const const T t5; // only in C 
typedef const T CT; 
CT const tcc; // fine, although CT was already const 

declarar exactamente lo mismo, una constante T. Si T ya tiene cv-calificadores, esto no cambia el significado de la calificación adicional.

Ahora, a la precedencia; Puede decir: "Quiero un puntero a una constante T":

const T (* tp); 

que por lo general se escribe como

const T* tp; 

porque el const une más fuerte que el * de todos modos.En el mismo patrón, se puede definir una variable que es "constante, sino que apunta a un mutable T":

T (* const tp) = 0; // must be initialised, because tp is immutable 

que comúnmente se escribe como

T* const tp = 0; 

En la misma línea que el operador subíndice [] es aplicado - con la misma precedencia que en expresiones.

0

El uso de const dos veces en un tipo es ilegal en C++ 2003 pero legal en C++ 2011 (consulte 7.1.6.1 [decl.type.cv] párrafo 1: "Las calificaciones de cv redundantes se ignoran"). Cuando usaste

static const TYPE const name[5]; 

hiciste TYPE constante dos veces. Tenga en cuenta, sin embargo, que esta declaración también es ilegal en C++ 2011, porque necesita inicializar un objeto const al declararlo. El significado de

const TYPE 

y

TYPE const 

es absolutamente equivalente: En ambos casos a tomar la constante TYPE objeto. Por coherencia, siempre pongo el const a la derecha porque todos, excepto el tipo de nivel superior, el const tiene que colocarse en el lado derecho (bueno, a menos que alguna directriz de codificación establezca un mandato diferente pero estoy luchando contra las directrices de codificación tontas).

Al usar punteros, los pensamientos se vuelven diferentes. Hay dos tipos implicados: tipo apuntado al tipo y el puntero. Cada uno de ellos puede estar compuesto const por separado:

TYPE const*  ptr1(0); // non-const pointer to const TYPE 
TYPE* const  ptr2(0); // const pointer to non-const TYPE 
TYPE const* const ptr3(0); // const pointer to const TYPE 

La mejor manera de averiguar lo que se hace const es leer la declaración de tipo de derecha a izquierda. Por supuesto, esto supone que los calificadores const se colocan en la ubicación correcta. Puede reemplazar const por volatile o const volatile en la discusión anterior y se aplica el mismo razonamiento.

Cuestiones relacionadas