C++ pregunta const

Question

Si hago esto:

// In header 
class Foo { 
void foo(bar*); 
}; 

// In cpp 
void Foo::foo(bar* const pBar) { 
//Stuff 
} 

El compilador no se queja de que las firmas para Foo :: foo no coinciden. Sin embargo si tuviera:

void foo(const bar*); //In header 
void Foo::foo(bar*) {} //In cpp 

El código no podrá compilarse.

¿Qué está pasando? Estoy usando gcc 4.1.x

Answer 1

La palabra clave const en el primer ejemplo no tiene sentido. Usted dice que no planea cambiar el puntero. Sin embargo, el puntero se pasó por valor y, por lo tanto, no importa si lo cambia o no; no afectará a la persona que llama. Del mismo modo, también se puede hacer esto:

// In header 
class Foo { 
void foo(int b); 
}; 

// In cpp 
void Foo::foo(const int b) { 
//Stuff 
} 

Incluso puede hacer esto:

// In header 
class Foo { 
void foo(const int b); 
}; 

// In cpp 
void Foo::foo(int b) { 
//Stuff 
} 

Desde el int se pasa por valor, el constness no importa.

En el segundo ejemplo, usted dice que su función toma un puntero a un tipo, pero luego lo implementa tomando un puntero a otro tipo, por lo tanto falla.

Answer 2

En el primero, ha prometido al compilador, pero no a otros usuarios de la clase, que no editará la variable.

En su segundo ejemplo, ha prometido a otros usuarios de la clase que no editarán su variable, pero no cumplieron esa promesa.

También debo señalar que hay una clara diferencia entre

bar* const variable 

y

const bar* variable 

y

const bar* const variable 

En la primera forma, el puntero no va a cambiar, pero puede editar el objeto al que apunta. En la segunda forma, puede editar el puntero (señalarlo a otro objeto), pero nunca la variable a la que apunta. En la forma final, no editarás el puntero ni el objeto al que apunta. Reference

Para agregar un poco más de aclaración a la pregunta planteada, siempre se puede prometer MÁS const que menos. Dada una clase:

class Foo { 
    void func1 (int x); 
    void func2 (int *x); 
} 

puede compilar la siguiente implementación:

Foo::func1(const int x) {} 
Foo::func2(const int *x) {} 

o:

Foo::func1(const int x) {} 
Foo::func2(const int* const x) {} 

sin ningún problema. Les ha dicho a sus usuarios que posiblemente puedan editar sus variables. En su implementación, le dijo al compilador que esta implementación particular no editará esas variables, aunque le haya dicho a los usuarios que podría hacerlo. No has incumplido una promesa para el usuario, por lo que el código se compila.

Answer 3

En el primero, el const no afecta a la interfaz, solo a la implementación. Le está diciendo al compilador, "No voy a cambiar el valor del bar* dentro de esta función". Aún puede cambiar lo que señala el puntero. En este último, le está diciendo al compilador (y a todas las personas que llaman) que no cambiará la estructura bar que bar*apunta a.

Answer 4

Ver this question, this question y this question.

Básicamente, la const solo significa que la función no modificará el valor del puntero. Los contenidos de los punteros no son const, lo mismo que la firma del encabezado.

Answer 5

Así que la segunda const en:

void Foo::foo(const bar* const); 

Es no parte de la firma del método?

Answer 6

Esto es más simple de entender con un tipo de variable que no sea un puntero. Por ejemplo, puede tener la siguiente declaración de la función:

void foo(int i); 

La definición puede tener este aspecto:

void foo(const int i) { ... } 

si la variable 'i' es const o no en el lado definición es un detalle de implementación . No tiene impacto para los clientes de esa función.

Answer 7

Probablemente no se preocupe demasiado por void Foo::foo(bar* const pBar) porque la forma en que se trata el puntero (const o no) no importa un poco fuera de la rutina. Las reglas de C dicen que ningún cambio en pBar viajará fuera de foo de ninguna manera.

Sin embargo, si es (const bar* pBar), eso hace la diferencia, porque significa que el compilador no permite que las personas que llaman pasen punteros a objetos no const.