I am designing a class that behaves like a C++ references but does some extra instrumental stuff (bookkeeping).
Initially I thought that std::reference_wrapper<T>
would be a good model. But after a while I realized that std::reference_wrapper<T>
doesn't behave, even in principle, as a C++ reference because assignment rebinds the internal pointer.
double a = 5.;
double b = 3.;
double& ref = a;
ref = b;
assert(&ref != &b); // ref is not bound to b
std::reference_wrapper<double> refwpr = a;
refwpr = b;
assert(&refwpr.get() == &b); // ref wrapper was rebound to b
I can of course change that behavior for my own class (not to rebind) but I though that maybe a class that emulates a reference is already out there. For example something like "std::real_reference<T>
".
Is there a class (standard or not) that emulates references more closely?
I think it can be useful too, for example in many places one sees
std::vector<std::reference_wrapper<T>>
presented as an alternative to std::vector<T&>
but this is misleading because the semantics is different but could be achieved with some modifications std::vector<std::real_reference<T>>
.
I now think that if a "perfect" reference wrapper were possible, then references could be just implemented with pointers and we wouldn't need T&
but just simply have a library feature reference<T>
that works exactly like T&
in all respects....
... which in turn means that the language could allow you to "overload" the &
attribute over types to produce a custom type instead of a language reference. For example using mytype& = custom_reference_emulator_of_mytype
.
template <typename T>
class Tref {
std::tuple<T &> t;
public:
template <typename... Args>
Tref(Args&&... args): t(std::forward<Args>(args)...) {}
operator T &() { return std::get<0>(t); }
decltype(&std::get<0>(t)) operator&() { return &std::get<0>(t); }
};
Tref<double &> t(a);
t = b;
assert(&t != &b);
What std::reference_wrapper
does is binding when the template erase the reference. You needn't build a class to meet your needs, and just use normal reference. (I may not describe clearly. My English is poor.)
来源:https://stackoverflow.com/questions/34235818/type-emulating-a-c-reference-better-than-stdreference-wrapper