implicit_cast isn't possible... is it?

[Tomás]

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_cas t.

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<u nsigned 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(c onst T& t) { return t; }

template <class U, class T>
inline U implicit_cast(T & t) { return t; }
void SomeFunc(unsign ed char) {}
void SomeFunc(signed char) {}
struct Base {

void SomeConstFuncti on() const {}

};

struct Derived : Base { Derived() {} };
int main()
{
SomeFunc( implicit_cast<u nsigned char>(27) );

SomeFunc( implicit_cast<s igned char>(27) );
Derived derived;

implicit_cast<B ase&>(derived) = Base();
Derived const cderived;

implicit_cast<c onst Base&>(cderived ).SomeConstFunc tion();

/* The line immediately above results in an ambiguity error */
}
(Initially I thought we'd have the problem of "implicit_c ast" creating a
temporary object when its U parameter is a non-reference type, but this
doesn't seem to be a problem because "static_cas t" does the same thing,
e.g.:)

/* Code Snippet C */

#include <iostream>
using std::cout;

#include <cstdlib>

struct Base {

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

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

};

struct Derived : Base {};

int main()
{
Derived derived;

static_cast<Bas e>(derived).Pri ntMyAddress();

cout << '\n';

static_cast<Bas e&>(derived).Pr intMyAddress();

cout << '\n';

std::system("PA USE");
}
Any ideas for resolving the ambiguity error in code snippet B?
-Tomás

[Tomás]

I've been trying to find a solution for this but haven't come up with
anything. Here's the closest I've gotten:

template <class U, class T>
inline U implicit_cast(c onst T& expr)
{
return static_cast<T&> (expr);
}
The problem though is that if "t" refers to an object which is actually
const, then "T" is STILL a non-const type. If "T" retained its constness,
such that the following defined a local const variable within the function:

T obj;

then the above code snippet would work as desired. But alas, it doesn't.
Of course my first attempt was:

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

template <class U, class T>
inline U implicit_cast(T & expr)
{
return expr;
}
but that resulted in ambiguity errors. I'm getting ambiguity errors for the
code snippet immediately above, but why DON'T I get ambiguity errors for
the following:

template<class T>
void Func ( const T& obj ) {}

template<class T>
void Func ( T& obj ) {}

int main()
{
int n = 5;

int const cn = 5;

Func(n);

Func(cn);

Func(5);
}
At first glance, it looks like a compiler bug -- I'm getting ambiguity
errors for "implicit_c ast" simply because it has two template parameters
rather than one, which just doesn't make sense.

-Tomás

[Victor Bazarov]

Tomás wrote:

I've been trying to find a solution for this but haven't come up with
anything. Here's the closest I've gotten:

template <class U, class T>
inline U implicit_cast(c onst T& expr)
{
return static_cast<T&> (expr);
}

[...]

Just wanted to ask (without doing much thinking yet)... Is there any
reason you wanted to use the reference argument instead of just 'T'?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Alf P. Steinbach]

* Tomás:

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_cas t.

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<u nsigned 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(c onst T& t) { return t; }

template <class U, class T>
inline U implicit_cast(T & t) { return t; }
void SomeFunc(unsign ed char) {}
void SomeFunc(signed char) {}
struct Base {

void SomeConstFuncti on() const {}

};

struct Derived : Base { Derived() {} };
int main()
{
SomeFunc( implicit_cast<u nsigned char>(27) );

SomeFunc( implicit_cast<s igned char>(27) );
Derived derived;

implicit_cast<B ase&>(derived) = Base();
Derived const cderived;

implicit_cast<c onst Base&>(cderived ).SomeConstFunc tion();

/* The line immediately above results in an ambiguity error */
}
(Initially I thought we'd have the problem of "implicit_c ast" creating a
temporary object when its U parameter is a non-reference type, but this
doesn't seem to be a problem because "static_cas t" does the same thing,
e.g.:)

/* Code Snippet C */

#include <iostream>
using std::cout;

#include <cstdlib>

struct Base {

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

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

};

struct Derived : Base {};

int main()
{
Derived derived;

static_cast<Bas e>(derived).Pri ntMyAddress();

cout << '\n';

static_cast<Bas e&>(derived).Pr intMyAddress();

cout << '\n';

std::system("PA USE");
}
Any ideas for resolving the ambiguity error in code snippet B?

First, that given 'Derived derived', the compiler is free to choose T =
'Derived' or 'T = Derived const'. Even if the latter would yield a
compilation error (as long as that error isn't covered by SFINAE rules).
And I think this is what's giving you an ambiguity problem.

So you'd want to enforce the same const'ness for types U and T, e.g.,
instead of specifying the argument type as T, specifying it like
'typename ConstVersion<T, IsConst<U>::yes >::Type&'.

Here's an example of detecting constness, not tested:

template< class T >
struct IsConst
{
static T& aT();
static SizeNFalse isConstArg( T& );
static SizeNTrue isConstArg( T const& );

enum{ yes = sizeof( isConstArg( aT() ) ) == sizeof( SizeNTrue ) };
};
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Tomás]

Victor Bazarov posted:

template <class U, class T>
inline U implicit_cast(c onst T& expr)
{
return static_cast<T&> (expr);
}

[...]

Just wanted to ask (without doing much thinking yet)... Is there any
reason you wanted to use the reference argument instead of just 'T'?

Implicit downcast from derived to base, and still retain L-value-ness:
implicit_cast<B ase&>(derived_o bject).SomeMeth od();
-Tomás

[Alf P. Steinbach]

* Alf P. Steinbach:

Here's an example of detecting constness, not tested:

template< class T >
struct IsConst
{
static T& aT();
static SizeNFalse isConstArg( T& );
static SizeNTrue isConstArg( T const& );

enum{ yes = sizeof( isConstArg( aT() ) ) == sizeof( SizeNTrue ) };
};

Uh, those args need to pointers, not references, in case no copy
constructor is available in T. Ditto for result of aT().

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[red floyd]

Alf P. Steinbach wrote:

* Alf P. Steinbach:

Here's an example of detecting constness, not tested:

template< class T >
struct IsConst
{
static T& aT();
static SizeNFalse isConstArg( T& );
static SizeNTrue isConstArg( T const& );

enum{ yes = sizeof( isConstArg( aT() ) ) == sizeof( SizeNTrue ) };
};

Uh, those args need to pointers, not references, in case no copy
constructor is available in T. Ditto for result of aT().

Why? You're never passing anything by value. You're passing and
returning T's by reference only, so no copy constructor is invoked on a T.

[Tomás]

To put things into perspective, here's a code snippet which uses
"static_cas t". I want to replace all instances of static_cast with
implicit_cast, and to have it behave identically:

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

class Base {
public:

Base() {}

void SomeConstFuncti on() const {}

void SomeNonConstFun ction() {}

};

class Derived : public Base
{
public:

Derived() {}

};
int main()
{
/* First we'll work with simple POD literals: */

SomeFunc( static_cast<uns igned char>(76) );
SomeFunc( static_cast<sig ned char>(76) );
/* Now we'll deal with L-value-ness */

Derived derived;

static_cast<Bas e&>(derived) = Base(); /* Just to demonstrate
L-valueness */
static_cast<Bas e&>(derived).So meNonConstFunct ion();
static_cast<con st Base&>(derived) .SomeConstFunct ion();

Derived const c_der;

static_cast<con st Base&>(c_der).S omeConstFunctio n();
// static_cast<Bas e&>(c_der); /* ERROR: Won't compile */

}
I presently have sample code which satisfies all the above requirements,
except that it DOESN'T result in a compile error if you try to compile
the last line of code I wrote above. Here it is:

template<class U, class T>
inline U implicit_cast( const T& expr )
{
return const_cast<T&>( expr);
}
-Tomás

[Tomás]

Here's my latest attempt (but still doesn't compile):
template<class T>
struct Wrapper {

typedef T TypeCV;

TypeCV &stored;

Wrapper( TypeCV &arg ) : stored(arg) {}

operator TypeCV&()
{
return stored;
}

};

template<class U, class T>
inline U implicit_cast( Wrapper<T> expr )
{
typedef typename Wrapper<T>::Typ eCV TypeCV;

return static_cast<Typ eCV&>(expr);
}
/* Here comes the code which has had "static_cas t" replaced
with "implicit_cast" . */
void SomeFunc( unsigned char ) {}
void SomeFunc( signed char ) {}

class Base {
public:

Base() {}

void SomeConstFuncti on() const {}

void SomeNonConstFun ction() {}

};

class Derived : public Base
{
public:

Derived() {}

};
int main()
{
SomeFunc( implicit_cast<u nsigned char>(76) );
SomeFunc( implicit_cast<s igned char>(76) );
Derived derived;
implicit_cast<B ase&>(derived) = Base(); /* Just to demonstrate
L-valueness */

implicit_cast<B ase&>(derived). SomeNonConstFun ction();
implicit_cast<c onst Base&>(derived) .SomeConstFunct ion();

Derived const c_der;

implicit_cast<c onst Base&>(c_der).S omeConstFunctio n();
// implicit_cast<B ase&>(c_der); /* ERROR: Won't compile */

}
-Tomás