Tengo una implementación de vector simple en C, que contiene una matriz de void*. Depende del usuario cuidar el tipo real.
Quiero 'prometer' que el vector no alterará su contenido, así que almaceno datos como:
Struct _Vector{ UInt32 used; UInt32 size; const void** arr; };No sé si se considera "exagerar" con mi corrección constante, pero trato de mantener la corrección constante con mis accesorios/modificadores:
void vector_add(Vector *v, const void* const elem); void vector_set(Vector *v, const UInt32 idx, const void* const elem);Cuando devuelvo un elemento del vector, es un puntero a los datos del usuario, por lo que dejo que el usuario modifique los datos a los que apunta, descartando la constancia en la matriz interna.
void* vector_get(const Vector *v, const UInt32 idx){ if ( idx >= v->used ) exitAtError("Vector","Array out of bounds"); return (void*)v->arr[idx]; }En lugar de devolver un const void* , devuelvo un void* en su lugar. La idea es que, internamente, quiero asegurarme de que no estoy cambiando los datos a los que se apunta, pero no me importa lo que suceda con los datos fuera del vector.
¿Se considera esto un uso correcto de const? Creo que está bien declarar los datos como constantes en un lugar, mientras que se pueden cambiar en otros lugares. No estoy seguro después de leer muchos artículos dogmáticos que afirman nunca desechar la constancia, y si se desecha, entonces el uso de la constancia no era apropiado para empezar.
Quiero 'prometer' que el vector no alterará su contenido
Esto es C. Las estructuras de datos no tienen comportamiento. Puede definir una estructura de datos vectoriales de modo que los datos apuntados en última instancia no se puedan modificar a través del vector, y eso es lo que ha hecho. Por supuesto, esto tiene sus implicaciones.
No sé si se considera "exagerar" con mi corrección constante, pero trato de mantener la corrección constante con mis accesorios/modificadores:
Si se va a molestar en absoluto con const , entonces, por todos los medios, adhiérase rigurosamente a const -correctness. De lo contrario, no tiene mucho sentido.
Cuando devuelvo un elemento del vector, es un puntero a los datos del usuario, por lo que dejo que el usuario modifique los datos a los que apunta, descartando la constancia en la matriz interna.
No. Lo has arruinado. const -la corrección necesita ser todo o nada para que valga algo.
Al descartar const , viola el contrato que su tipo Vector hace con sus usuarios al permitir que los valores señalados se modifiquen a través de una instancia. Indirectamente, sin duda, pero eso no importa. Además, esto puede contribuir a violaciones más amplias de la corrección const : suponga, por ejemplo, que los datos ingresados en su vector fueran const en primer lugar. Entonces, almacenarlos en su estructura de datos estaría bien, pero proporciona funciones que podrían permitir que se modifiquen (o al menos permitiría intentarlo).
Podría considerar usar una estructura de datos opaca en lugar de calificar const a los miembros para evitar que se acceda a los elementos directamente a través de los vectores. Sin embargo, en última instancia, la corrección constante requerirá estructuras de datos y funciones separadas para los vectores que contienen datos const y aquellos que contienen datos que no son const .
Consideraría esto una mala idea, ya que permite escribir en objetos constantes sin previo aviso. Por ejemplo:
const int x = 5; vector_add(&v, &x); int *p = vector_get(&v, 0); *p = 6; // oops En su lugar, devuelva const void * . Luego, puede dejar que la persona que llama tome la decisión sobre cuándo descartar const.
Probablemente terminará teniendo dos versiones del vector, una con void * y otra con const void * .
Si bien otras respuestas son correctas en una perspectiva de corrección constante limitada, debe tener en cuenta que en C una vez que el puntero ingresó a este vector, no hay forma de saber si los datos son [in] mutables. En este caso, vector no debería preocuparse por eso y siempre tomar y devolver punteros no constantes. Si alguien quiere pasar un puntero constante allí , lanzará y se encargará de anular el lanzamiento cuando haga get(). Es responsabilidad del usuario restaurar la semántica de almacenamiento inicial, tal como la conoce.
Su afirmación real aquí es que nunca eliminará la referencia del puntero, pero no que sea constante. Solo escribe eso en docs.