C++ conversion const pass-by-reference

Given a template pass-by-reference conversion/type-cast operator (without const) is possible:

class TestA
{
    public:

        //Needs to be a const return
        template<typename TemplateItem>
        operator TemplateItem&() const {TemplateItem A; A = 10; return A;}
};

int main()
{
    TestA A;
    {
        int N;
        N = A;
        printf("%d!\n",N);
    }
    {
        float N;
        N = A;
        printf("%f!\n",N);
    }
    return 0;
}

And given the following code (with const):

class TestA
{
    public:

        //Produces error
        template<typename TemplateItem>
        operator const TemplateItem&() const {TemplateItem A; A = 10; return A;}
};

Produces these errors:

error: cannot convert 'TestA' to 'int' in assignment

error: cannot convert 'TestA' to 'float' in assignment

Question

How do I make it so the conversion/type-cast operator return a const pass-by-reference of the template type?

Context

Before most people come in and freak about how 'you can't convert it to just anything', you'll need context. The above code is pseudo code - I'm only interested on const reference returns being possible, not the pitfalls of a templated conversion function. But if you're wondering what it's for, it's relatively simple:

TemplateClass -> Conversion (turned into byte data) -> File

TemplateClass <- Conversion (changed back from byte data) <- File

The user is expected to know what they开发者_如何学JAVA are getting out, or it's expected to be automated (I.E. saving/loading states). And yes, there is a universal method for templates using pointers to convert any type into byte data.

And don't give me claptrap about std doing this sort of thing already. The conversion process is part of a more complicated class library setup.

I'm a programmer. Trust me. C++ trusts me and lets me make mistakes. Only way I'll learn.

Firstly, your conversion operator is already undefined behavior because you return a reference (const or not) to a local variable that has gone out of scope. It should work fine if you change your conversion operator to return by value which won't induce UB.

EDIT: (removed incorrect information about conversion operators).

But are you really sure that you really want your class type to be convertible to anything? That seems like it's just going to cause many headaches in the future when you're maintaining the code and it converts to an unexpected type automatically.

Another possible implementation is to create an as template method that basically does what your conversion operator wants to do and call it like obj.as<int>().