operador - punteros c++

C/C++: Punteros dentro de Const Struct

Question

¿Cómo fuerzo la const-ness de la memoria apuntada por obj-> val1 en la función fn?

#include <iostream>
struct foo {
int* val1;
int* val2;
int* val3;
};
void fn( const foo* obj )
{
// I don''t want to be able to change the integer that val1 points to
//obj->val1 = new int[20]; // I can''t change the pointer,
*(obj->val1) = 20; // But I can change the memory it points to...
}
int main(int argc, char* argv[])
{
// I need to be able to set foo and pass its value in as const into a function
foo stoben;
stoben.val1 = new int;
*(stoben.val1) = 0;
std::cout << *(stoben.val1) << std::endl; // Output is "0"
fn( &stoben );
std::cout << *(stoben.val1) << std::endl; // Output is "20"
delete stoben.val1;
return 0;
}

El código aquí es bastante autoexplicativo. Necesito poder hacer un objeto no const y llenarlo con datos, pero luego pasarlo a una función donde estos datos no se pueden modificar. ¿Cómo puedo hacer esto?

Sé que puedo pasar un puntero int de const, pero en teoría, esta clase contiene otros punteros que también necesitaré en "fn".

Gracias,

Griff

Answer 1

Como etiquetó como C ++, puede hacer que el miembro sea private y crear un acceso que devuelva un const int * . Originalmente podría establecer el miembro a través de su constructor o una función de friend .

Answer 2

No soy una persona de C ++, pero en C, manejaría esto a través de dos declaraciones struct diferentes, una pública, una privada:

#include <stdio.h>
#include <stdlib.h>
struct private_foo {
int* val1;
int* val2;
int* val3;
};
struct public_foo {
int const * const val1;
int const * const val2;
int const * const val3;
};
void fn( struct public_foo * obj )
{
int local;
*(obj->val1) = 20; // compile error
obj->val1 = &local; // compile error
}
int main(int argc, char* argv[])
{
// I need to be able to set foo and pass its value in as const into a function
struct private_foo stoben;
stoben.val1 = malloc(sizeof(int));
if (!stoben.val1) { return -1; }
*(stoben.val1) = 0;
printf("%d", *(stoben.val1) );
fn( (struct public_foo *) &stoben );
printf("%d", *(stoben.val1) );
free(stoben.val1);
return 0;
}

Cuando intento compilar el w / GCC anterior, obtengo los siguientes errores de compilación, ya que estoy tratando de modificar la memoria de solo lectura:

temp.c: In function ‘fn’:
temp.c:20: error: assignment of read-only location
temp.c:21: error: assignment of read-only member ‘val1’

Answer 3

Realmente no puedes. Un const foo especifica que los miembros internos son const, es decir, son punteros constantes para enteros, no punteros a enteros constantes.

La solución adecuada para esto sería a través de la encapsulación, ocultando estos miembros y proporcionando una interfaz pública. Una solución práctica, si tiene prohibido modificar la estructura foo, sería a través de la herencia privada:

struct foo {
int* val1;
int* val2;
int* val3;
};
struct constFoo : private foo {
public:
const int* getVal1() { return val1; }
const int* getVal2() { return val2; }
const int* getVal3() { return val3; }
};

Por supuesto, necesitaría crear los constructores apropiados, etc., para que se pueda configurar el foo original.