Prevent prvalue from being bound to a variable

I have a function that returns a temporary object which holds a reference inside and its sole purpose is to allow a sort of return-type overloading. For example:

#include <iostream>
#include <vector>

class MyData {
private:
    class IntOrChar {
    public:
        IntOrChar(char const& c) : c_(c) {}
        operator char() { return c_; }
        operator int() { return c_-'0'; }
    private:
        char const& c_;
    };

public:
    MyData(std::string number) : number_(number) {}

    IntOrChar get(std::size_t i) { return number_[i]; }

private:
    std::string number_;
};

void accepts_char(char c) { std::cout << "char: " << c << '\n'; }
void accepts_int(int i) { std::cout << "int: " << i << '\n'; }

int main(){
    MyData n("012345");
    accepts_char(n.get(3));
    accepts_int(n.get(3));
}

The actual code is more complex, and the reference is to some internal state.

Using the above example, can I prevent the value returned from get() from being held on to? I want to prevent code like this:

MyData n("0123");
auto r = n.get(2);
... // much later in the code
accepts_char(r);

since at the point where it is being used, the internal reference may no longer be valid. I want to force the casting class (IntOrChar) to be cast to a concrete type immediately and not held on to.

I think the terms I am looking for are that I want to prevent the prvalue from being turned into an xvalue?

I just want to prevent this from being done by accident. I don't care if it can be gotten around using some type of force-casting or other wizardry.

A workaround is to make the conversion functions &&-qualified. Anyone who asks why they’re having to write accepts_char(std::move(r)) can be reminded of the purpose of the type.

The real answer is to mark the type lifetime-bound, but that’s very much still a proposal. Another possibility for the exact example given would be to make auto fail for the type, but that’s also merely a proposal.