c++ - significado - que es declaracion de variables

¿Hay alguna forma en C++ para crear variables ''súper privadas''?

Question

Tenía una idea para una característica para C ++, y me preguntaba si era posible crearla.

Digamos que quiero que una variable privada en ''MyClass'' sea accesible solo por dos funciones, la que obtiene y configura el público. Es decir, si otra función pública o privada de MyClass intenta obtener o cambiar el valor de mi variable super-privada, obtendré un error de compilación. Sin embargo, el getter y setter se comportan normalmente.

¿Algunas ideas?

Edición 1: Un caso de uso es hacer que el getter / setter realice una comprobación de errores u otra forma de lógica. No querría que la clase tocara directamente la variable.

Edición 2: algo como esto entonces:

template <class T>
class State{
private:
T state;
public:
State()
{
state = 0;
}
T getState()
{
return state;
}
void setState(T state)
{
this->state = state;
}
};

Y luego cualquier clase puede heredarlo y acceder al ''estado'' solo a través del getter / setter. Por supuesto, la clase es inútil sin modificar el getter y el setter de acuerdo con su lógica deseada.

Answer 1

Creo que esto es lo que pediste. ¿Es deseable? Algunas personas pensarán que esto es una abominación.

Si decidió usarlo, probablemente querrá sacar de la macro Get y Set públicos y escribirlos manualmente.

#define SUPER_PRIVATE(c,t,m) /
template <typename C, typename T> /
class SuperPrivate##m { /
friend T& C::Get##m(); /
friend void C::Set##m(const T&); /
T value; /
}; /
public: /
t& Get##m() { return m.value; } /
void Set##m(const t& value) { m.value = value; } /
private: /
SuperPrivate##m<c,t> m;
class SomeClass
{
public:
SomeClass()
{
SetX(42);
SetY(58);
}
int DosomethingWithX() { return GetX() * 2; }
// int DosomethingWithX2() { return X.value * 2; } // error
// int DosomethingWithX3() { return X; } // error
SUPER_PRIVATE(SomeClass, int, X);
SUPER_PRIVATE(SomeClass, int, Y);
};
int main()
{
SomeClass someObject;
int x1 = someObject.GetX();
int y1 = someObject.GetY();
someObject.SetY(89);
int y2 = someObject.GetY();
int x2 = someObject.DosomethingWithX();
}

Answer 2

La granularidad de la accesibilidad en C ++ es la clase.

Entonces, si necesita hacer que una variable sea accesible a solo dos métodos, necesita mover la variable y los dos métodos a una clase separada, dedicada a mantener la privacidad.

Answer 3

Podrías envolver la variable en una clase y hacerla privada allí y una const T& getter. A continuación, declara las funciones de obtención y configuración de miembros de la clase contenedora como amigos para ese contenedor. Ahora conserva la clase wrapper como miembro en su clase original. Eso debería lograr lo que se desea, aunque parece difícil de mantener y no es muy útil.

Así que aquí hay una implementación ficticia que muestra cómo funcionaría esto (Tenga en cuenta que todo el new VeryPrivateWrapper negocio de new VeryPrivateWrapper es simplemente una forma extraña de las declaraciones, un unique_ptr sería más útil):

class VeryPrivateWrapper;
class Original {
VeryPrivateWrapper* m_wrapper;
public:
Original();
// imagine that I remembered the rule of three here
void set(int);
void other();
};
// make this a template for more fun
class VeryPrivateWrapper {
int m;
public:
const int& get() const { return m; }
// !!!
// the important bit
// !!!
friend void Original::set(int);
};
Original::Original() : m_wrapper(new VeryPrivateWrapper) {}
void Original::set(int i) {
m_wrapper->m = i;
}
void Original::other() {
// this borks as we would like
// m_wrapper->m = 23;
}
int main()
{
Original o;
o.set(3);
return 0;
}

Answer 4

Yo pondría un nombre muy feo a la variable, y uno agradable al que lo tiene / lo pone:

class Foo
{
private:
int _hey_do_not_use_me_im_super_private_whatever;
public:
int get_whatever() const
{
//extra logic
return _hey_do_not_use_me_im_super_private_whatever;
}
void set_whatever(int we)
{
//extra logic
_hey_do_not_use_me_im_super_private_whatever = we;
}
};

Un comentario que explique qué medios súper privados será más bienvenido por las personas que heredan su código.