asignar un valor a Y, y que X seja Y+1 automaticamente

[vangodp]

Hola amigos! Me surgió una duda. ¿ Seria posible que yo tuviera 2 variables int llamadas x e outra y, e que al hacer y=10, x pasase a valer y+1 porem sin hacer cosas como x=y+1 o por el estilo, yo simplemente mudo el valor de y e quedria que x pasase a valer a mesmacoisa mais um sem pasos posteriores.

int x;
int y;

y = 10; // y vale 10, e x deveria valer y+1

cout << y; // 10
cout << x; // 11


Para que vea más o menos lo que quedria hacer es algo como:
Y = 10;

X = (&Y) + 1;

cout<<X<<endl; //10

Y = 20;

cout<<x<<endl;//21

pero no quiero hacer cosas como esa cada vez que mude el valor de Y:
Y = 10;

X = Y+ 1;

cout<<X<<endl; //10

Y = 20;
X = Y+ 1;

cout<<x<<endl;//21

Es solo curiosidad >_<. Gracias y que pasen un buen finde

[Instru]

Ehm. No, eso específicamente no se puede hacer.

Hay muchos trucos para simular algo asi.

El mas facil que se me ocurre es que en vez de que x sea una variable, que sea una función.

Entonces cada vez que mandes llamar x, te va a imprimir y+1 (siempre y cuando y sea una variable global).

Te recomiendo que no hagas eso. La idea de la programación es que puedas leer y entender rápidamente que hace el código. Si usas trucos como el que te digo, se vuelve mas difícil leer y entender el código. Y así que digas cuanto te ahorras de teclear, pues tampoco...

Saludos

[vangodp]

¡Sí! Sé que es algo descabellado XD, pero por saber si se puede.... Gracias

[enrieto]

Pero sí, como no se va apoder; en C++ se puede todo

Código C++:

#include <iostream>
 
class sig {
    const int* n;
public:
    sig(const int& i) : n{&i} {}
    sig(int&&) = delete;
    operator const int() const { return *n + 1; }
};
 
int main()
{
    int y = 10;
    sig x = y; // x es el siguiente de y
 
    std::cout << "x = " << x << std::endl;
 
    y = 20;
    std::cout << "x = " << x << std::endl;
}
 

[eferion]

Buena solución enrieto. Lo único que te aconsejaría cambiar el puntero por una referencia... Así evitas que te puedan pasar punteros nulos.

Un saludo

[dehm]

Hola:

¿Cual es el objeto de esta línea?:

Código C++:

sig(int&&) = delete;
 

[enrieto]

eferion aconseja:

...te aconsejaría cambiar el puntero por una referencia... Así evitas que te puedan pasar punteros nulos.

La clase se instancia con un int, no con un puntero.

dehm pregunta:

¿Cual es el objeto de esta línea?:
sig(int&&) = delete;

Es para evitar que alguien vaya a querer hacer

Código C++:

sig a = 10;
 

[eferion]

Iniciado por enrieto

eferion aconseja:
La clase se instancia con un int, no con un puntero.

No me refería a eso. La clase internamente utiliza un puntero. Si el objeto al que apunta, en este caso un int, y no se va a permitir el cambio de referencia, es más limpio usar una referencia en vez de un puntero.

La razón que subyace es que en mantenimientos posteriores a nadie se le ocurre ponerle un delete a una referencia, mientras que a un puntero...

Yo me refería a algo tal que:

Código C++:

class sig {
    const int& n;
public:
    sig(const int& i) : n{i} {}
    sig(int&&) = delete;
    operator const int() const { return n + 1; }
};
 

Un saludo

[vangodp]

Gracias enrieto y gracias eferion, muy interesante la propuesta, aun no lo pillo lo que ha referido dhen sig(int&&) = delete;, entiendo para lo que es pero no entiendo como trabaja, como muchas otras cosas de C++. XD

[eferion]

Iniciado por vangodp

muy interesante la propuesta, aun no lo pillo lo que ha referido dhen sig(int&&) = delete;, entiendo para lo que es pero no entiendo como trabaja, como muchas otras cosas de C++. XD

Código C++:

sig a = 4;
 

En el código anterior, 4 es un prvalue(hasta C++98) o rvalue(C++11 en adelante). Para no aburrir con toneladas de teoría que ya están en Internet, lo resumo rápidamente.

rvalue únicamente puede ser gestionado por los siguientes constructores:

Código C++:

sig(int);
sig(int&&);
 

La idea es deshabilitar la opción de indexar rvalue ya que sig únicamente almacena un puntero y obtener una referencia de un elemento que en la instrucción siguiente ya no va a existir suena bastante peligroso.

El caso es que el primer constructor queda "tapado" por la implementación de sig(const int&) por lo que no nos tenemos que preocupar por él. El segundo, sin embargo, toca deshabilitarlo explícitamente para evitar errores...

Como detalle adicional, la sintaxis de doble '&' se implementó en el estándar C++11 y va asociada a la semántica move. Internet está sembrada de información acerca de dicha semántica, sus repercusiones, usos y razón de ser.

Un saludo.