Re: implicit_cast isn't possible... is it?

Given the following:

    static_cast<T>( expr )

This will evaluate to an l-value if T is a reference type -- otherwise it
will evaluate to an r-value.
The same goes for reinterpret_cast.

I've been trying to write an "implicit_cast", but I don't think it's
possible to achieve the same behaviour.

For instance, here would be its most basic use:

/* Code Snippet A */

void SomeFunc( signed char ) {}
void SomeFunc( unsigned char ) {}

int main()
{
    SomeFunc( implicit_cast<unsigned char>(45) );
}

But then if we simulatenously try to achieve the l-value behaviour, it
won't compile -- giving an ambiguity error. Here's the code I have so
far:

/* Code Snippet B */

template <class U, class T>
inline U implicit_cast(const T& t) { return t; }

template <class U, class T>
inline U implicit_cast(T& t) { return t; }

void SomeFunc(unsigned char) {}
void SomeFunc(signed char) {}

struct Base {

    void SomeConstFunction() const {}

};

struct Derived : Base { Derived() {} };

int main()
{
    SomeFunc( implicit_cast<unsigned char>(27) );

    SomeFunc( implicit_cast<signed char>(27) );

    Derived derived;

    implicit_cast<Base&>(derived) = Base();

    Derived const cderived;

    implicit_cast<const Base&>(cderived).SomeConstFunction();

    /* The line immediately above results in an ambiguity error */
}

(Initially I thought we'd have the problem of "implicit_cast" creating a
temporary object when its U parameter is a non-reference type, but this
doesn't seem to be a problem because "static_cast" does the same thing,
e.g.:)

/* Code Snippet C */

#include <iostream>
using std::cout;

#include <cstdlib>

struct Base {

    void PrintMyAddress() const
    {
        cout << static_cast<const void*>(this);

        /* Here's an instance where I'd use
           implicit_cast */
    }

};

struct Derived : Base {};

int main()
{
    Derived derived;

    static_cast<Base>(derived).PrintMyAddress();

    cout << '\n';

    static_cast<Base&>(derived).PrintMyAddress();

    cout << '\n';

    std::system("PAUSE");
}

Any ideas for resolving the ambiguity error in code snippet B?