One way modification of reference variables - c++

Question

For example, I have this code.
#include <iostream>
using namespace std;
int main()
{
int x = 5; //Original variable
int &y = x; //Reference variable to x.
y = 10; //Modifying reference variable.
cout<<x<<" "<<y<<endl;
x = 5; //Modifying original variable.
cout<<x<<" "<<y<<endl;
}
It gives the expected output.
10 10
5 5
Shows that modifying either the original variable or the reference variable changes them both - Pretty obvious.
My question is that:
Can a reference variable be defined in such a way that modifying it DOES NOT modify the original variable?
I know then it wouldn't be called a reference variable.
To make things more clear,
Modifying x should modify y, but modifying y should not modify x. That is, y should be an independent copy of x, but should change as and when x changes.
Can this be possible?
Yes, I can create my own logic to emulate this, but I was wondering if C++ catered to this by default.

Answer 1

There is no language construct that can immediately give you what you seek but you can implement it fairly straightforward by encapsulating x and y.
struct XChangesY{
set_x(int x_and_y){ y = x = x_and_y; }
set_y(int y_){ y = y_; }
int get_x(){ return x; }
int get_y(){ return y; }
private:
int x;
int y;
}

Answer 2

No, what you want to do isn't possible. Consider what happens if you modify both y and x. Where does y take its value then? From the updated value of x which should modify both x and y, or from the updated value of y which should update y only and not x?
The only way forward is to implement your own logic. In any case, you need to have two int variables.

Answer 3

Sure, but it's not elegant--
template<typename T>
class C
{
public:
C(T t) : m_t(new T(t)), t_local(t), is_copy(false) {}
C(const C& c) : m_t(c.m_t), t_local(t), is_copy(true) {}
T Get() { return *m_t; }
T GetLocal() { return t_local; }
void Set(T t)
{
t_local = t;
if (!is_copy) *m_t = t;
}
private:
T* m_t;
T t_local;
bool is_copy;
};
And your setup creates an ambiguity when it comes to evaluating y, after both it has been changed--do you want the value of x, or the new, different value of y? I don't see any way to avoid creating separate methods for each case.

Answer 4

C++ does not provide a mechanism for doing this automatically, but you can make a class that supports the behavior that you are trying to make.
Here is a grossly oversimplified version of what you can do:
class IntRef {
int *ptr;
int copy;
public:
IntRef(int& d) : ptr(&d) {}
IntRef& operator=(const int& rhs) {
// Detach from the original on assignment
copy = rhs;
ptr = ©
}
operator int() const {
return *ptr;
}
};
int main() {
int x = 5; //Original variable
IntRef y(x); //Reference variable to x.
x = 5; //Modifying original variable.
cout<<x<<" "<<y<<endl;
y = 10; //Modifying reference variable.
cout<<x<<" "<<y<<endl;
return 0;
}
Demo.
This prints
5 5
5 10
The idea of the implementation above is to keep a pointer pointing to the original value for as long as y is not assigned. After the assignment the pointer is switched to a copy that is kept internally.

Answer 5

What you're looking for isn't inherently built-in the language - having two variables sharing the same value, changing one changes both but changing the other one only changes one.
That question though is similar to shared pointers and reference counters. For example, when you make a copy of a std::string, the content of the string isn't copied. A new string object is created with a pointer to the same data as the first string, and a reference counter.
So both strings share the same data. But when you change one - either one - and the reference counter is more than one, then that string dissociates itself and copies the data, and both strings are no longer linked. This is in order to avoid duplicated long strings of data when there's no need.
The same thing happens with Qt containers (QByteArray, QMap, QList, ...).
Another way to look at your problem is a logic of watcher - data received from outside updates the internal value, but the internal value can be changed by other means. Qt's signals/slot feature can be used to do that naturally, or you can easily implement your own logic to do that yourself.

Answer 6

Seems like what you want is copy-on-write semantics. Something like this might work for you, but is easily abused:
template <class T>
class cow_ptr
{
public:
using ref_ptr = std::shared_ptr<T>;
private:
ref_ptr m_sp;
bool m_original; //don't detach the original
void detach()
{
T* tmp = m_sp.get();
if( !( tmp == 0 || m_sp.unique() || m_original ) ) {
m_sp = ref_ptr( new T {*tmp} );
}
}
public:
cow_ptr(T* t)
: m_sp{t}, m_original{true}
{}
cow_ptr(const ref_ptr& refptr)
: m_sp{refptr}, m_original{true}
{}
cow_ptr(const cow_ptr& cowptr)
: m_sp{cowptr.m_sp}, m_original{false}
{}
cow_ptr& operator=(const cow_ptr& rhs)
{
m_sp = rhs.m_sp;
return *this;
}
const T& operator*() const
{
return *m_sp;
}
T& operator*()
{
detach();
return *m_sp;
}
const T* operator->() const
{
return m_sp.operator->();
}
T* operator->()
{
detach();
return m_sp.operator->();
}
};
Then you can use it like this:
int main()
{
auto x = cow_ptr<int>{ new int{5} };
auto y = x;
const auto &yr = y; //so dereferencing doesn't detach
cout<<*x<<" "<<*yr<<endl; //5 5
*x = 10;
cout<<*x<<" "<<*yr<<endl; //10 10 (updating x updated y)
*y = 15;
cout<<*x<<" "<<*yr<<endl; //10 15 (updating y did not update x)
//from now on, changing x will not change y
}