避免将左值引用绑定到临时数据容器和包装器的设计

Question

I'm struggling with the design of a few (probably two) C++ classes that work together and implement sort of a data container (Vector) and a data wrapper (Integer) that wraps individual vector elements (or better to say the access to it). The Vector simply holds a vector of int . The Integer/wrapper provides access to an int (possibly without holding it).

Requirements:

1. Wrapper/Integer must be available as lvalue
2. The data container should hold the data as an vector of int (not as a vector of Integer)
3. The wrapper also holds some other data members (no reinterpreting cast int -> Integer possible)

I fail to design this (see below) without running into the problem where an lvalue reference cannot bind to a temporary. I understand that that's not possible and I understand that code is wrong (and why it's wrong). There's no need to explain that lvalue references can't bind to rvalues. I'm struggling to find a solution to above requirements without this problem.

How to design this in C++? (Can be any modern standard)

#include<vector>
        
class Integer
{
  int& ref_t;
  bool other_data_member;

public:
  Integer(int& rhs): ref_t(rhs) {}

  Integer& operator=( int i )
  {
    ref_t = i;
    return *this;
  }
};



class Vector
{
  std::vector<int> data;

public:
  Vector(): data(10) {}
  
  Integer& operator[](int i)
  {
    return Integer( data[i] ); // caution: this doesn't work
  }
};



void write_one( Integer& i )
{
  i = 1;
}


int main()
{
  Vector v;
  write_one( v[5] );
}

Answer 1

Returning a “temporary” by value doesn't make a copy or even a move (guaranteed as of C++17, though often implemented as a conforming optimization in prior versions). You have to do this, because your operator[] needs to form a new wrapper for whatever index. (The reinterpret_cast approach has undefined behavior regardless of other members of Integer .) Generic code can bind auto&& to your proxy object because of lifetime extension , and can assign to it, so often need not be aware of the proxy (as is desirable).

Separately, if you want to avoid copying arguments to functions like write_one that do know about the proxy type, you can accept const Integer& . To make that work, make your operator= const (which sounds weird until you remember that it's not the Integer that's being modified).