How to make a "synthetic" lvalue?

Most probably what I am asking for already has been
answered somewhere, still I was not able to find:-(

I want to encapsulate a class ( a primitive type for
the beginning ) to behave like a lvalue, but instead
of living in process memory being forwarded to some
remote store.

I believe an lvalue needs to be able to be convertible
to its wrapped type on reading, and providing an
assign function (operator =) for writing.

The following snippet illustrates the idea:

#include <iostream>
#include <map>
#include <string>

// a model of the store on the remote end
std::map<std::string, intstore;

// the call to the remote store sets a value
void set(std::string key, int val)
{
store[key] = val;
}

// this call to the remote store reads a value
int get(std::string key)
{
return store[key];
}

// the template wraps a native type
template<class T>
class remote_lval
{
public:
remote_lval(std::string key)
: key_(key)
{}

operator T()
{
return get(key_);
}

T operator = (T val)
{
set(key_, val);
return val;
}

private:
const std::string key_;
};

int main
(
int argc
, char* argv[]
)
{
remote_lval<intfoo("foo");
int bar;
int baz;
remote_lval<intfoobar("foobar");
remote_lval<int>& hmm(foobar);

foobar = baz = foo = bar = 42;

std::cout << foobar << ", " << baz << ", " << foo << ", " << bar <<
", " << hmm << std::endl;

foobar = foo + baz;

std::cout << foobar << ", " << baz << ", " << foo << ", " << bar <<
", " << hmm << std::endl;

return 0;
}

Altough the above code apparently works, I am not sure if I am
overseeing something important. I intend to extend the idea to
make the key_ a pos_type into a stream and be able to treat file
space like a memory space. I know that there will be issues of
caching and concurrency, but for the beginning I want to get the
lval wrapper right.

If anyone thinks what I am trying to do is a bad idea, I would be very
glad to learn the reasoning "why" it is a bad idea, before going
any further.

Thank you for your kind attention.

Roland aka. speedsnail