Francamente, creo que es menos confuso si una variable es o bien const o no, que si esto puede cambiar.
Para elaborar un poco sobre esto: La razón por la que normalmente se quiere hacer esto es porque no se puede inicializar una variable const la forma en que desea. std::vector es un buen ejemplo de esto. Bueno, por una vez, la siguiente norma introduce una sintaxis de inicialización universal que hace esto posible:
const std::vector<int> cvi = { 1, 2, 3, 4, 5, 42 };
Sin embargo, incluso sin cosas C++ 1x' a la mano, e incluso con tipos que no permiten esta sintaxis de inicialización, puede siempre crear una función auxiliar para hacer lo que quiera:
const std::vector<int>& cvi = create_my_vector();
o, si se quiere ser de lujo:
const std::vector<int>& cvi = compile_time_list<1,2,3,4,5,42>::create_vector();
Nota del &. No tiene sentido copiar el resultado de la llamada a la función, ya que vincular un valor r a una referencia const amplía su duración hasta el final de la vida útil de la referencia.
Por supuesto, volver a compilar con un compilador que admita la semántica de movimiento de C++ 1x hará que esas optimizaciones sean prácticamente innecesarias. Pero vincular un rvlaue a una referencia const puede ser aún más rápido que mover un vector y es poco probable que sea más lento.
Con C++ 1x, también puede crear funciones lambda haciendo esto una sola vez. C++ solo proporciona un arsenal de herramientas increíblemente grande. IME, no importa cuánto haya pensado, alguien más debería pensar en otra idea para hacer lo mismo. Y a menudo uno mejor que el tuyo.
Sin embargo, IME este problema generalmente solo viene con demasiado código en muy pocas funciones de todos modos. Y luego no solo se aplica a la constness, sino también a rasgos similares, como a lo que se refiere una referencia.
Un clásico es el uso-uno-de-varios-posibles-streams.En lugar de esto
int main(int argc, char* argv[])
{
std::istream* istrm = NULL;
std::ifstream ifs;
if(argc > 1)
{
ifs.open(argv[1]);
if(ifs.good())
istrm = &ifs;
}
if(!istrm)
istrm = &std::cin;
while(istrm->good())
{
// reading from *istrm implemented here
}
return 0;
}
simplemente dividir las preocupaciones en: 1) averiguar dónde leer y 2) la lectura real:
int read(std::istream& is)
{
while(is.good())
{
// reading from is implemented here
}
return 0;
}
int main(int argc, char* argv[])
{
if(argc > 1)
{
std::ifstream ifs(argv[1]);
if(ifs.good())
return read(ifs);
}
return read(std::cin);
}
todavía tengo que ver un ejemplo del mundo real de una variable eso no fue tan constante como podría haber sido, lo que no pudo solucionarse separando las preocupaciones.
¿Qué sucede si constifica v en una sola rama de un if-then-else? –
Entonces probablemente debería ser 'const' solo en ese ámbito. – Frank
No. No tendría sentido. –