C++Talk.NET

Kyung Kook Park · Guest

Hi,

I am trying to compile the following code segment both on VC and GCC.
Basically it's implementing a cast-like function which is similar to
static_cast<First>(Second). The first template argument is given by the
programmer and the other is deduced by the compiler.

It turned out this code compiles successfully on VC but not on GCC
because of ambiguity in choosing the second template parameter. It
seems that GCC cannot deduce the type from function argument once the
programmer explicitly specifies former argument even though it's only
partial. Is this a standard behavior or what?

#include <stdio.h>

template < class _ToType, class _FromType >
void solid_cast( const _FromType &from )
{ printf("_Type const &n"); }

template < class _ToType, class _FromType >
void solid_cast( _FromType &from )
{ printf("_Type &n"); }

int main(void)
{
int n = 10;
const int &c = n;
solid_cast< const int & >( n );
solid_cast< const int & >( c );

return 0;
}

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Kyung Kook Park · Guest

chuck roast
3 lb. prime baby butt
2 tablespoons each:
salt
black, white and cayenne peppers
celery salt
garlic powder
parsley flakes
brown sugar
1 teaspoon sage
2 onions
6 cloves garlic
bunch green onions, chopped

Cut the children?s butts and the beef roast into pieces
that will fit in the grinder.
Run the meat through using a 3/16 grinding plate.
Add garlic, onions and seasoning then mix well.
Add just enough water for a smooth consistency, then mix again.
Form the sausage mixture into patties or stuff into natural casings.

Stillborn Stew

By definition, this meat cannot be had altogether fresh,
but have the lifeless unfortunate available immediately after delivery,
or use high quality beef or pork roasts (it is cheaper and better to
cut up a whole roast than to buy stew meat).

1 stillbirth, de-boned and cubed
¼ cup vegetable oil
2 large onions
bell pepper
celery
garlic
½ cup red wine
3 Irish potatoes
2 large carrots

This is a simple classic stew that makes natural gravy,
thus it does not have to be thickened.
Brown the meat quickly in very hot oil, remove and set aside.
Brown the onions, celery, pepper and garlic.
De-glaze with wine, return meat to the pan and season well.
Stew on low fire adding small amounts of water and
seasoning as necessary.
After at least half an hour, add the carrots and potatoes,
and simmer till root vegetables break with a fork.
Cook a fresh pot of long grained white rice.

Pre-mie Pot Pie

When working with prematurely delivered newborns (or chicken) use sherry;
red wine with beef (buy steak or roast, do not pre-boil).

Pie c

Thomas Maeder · Guest

"Kyung Kook Park" <kyungk (AT) gmail (DOT) com> writes:

annamalai.gurusami@gmail. · Guest

The template argument itself will take care of the const and non-const
versions of the function. This is because "const int" and "int" are
different template argument values. So there is no separate
overloading required.

The only template definition that is required is

template < class _ToType, class _FromType >
void solid_cast( _FromType &from )
{
cout << typeid(from).name() << endl;
}

Since the types "const int" and "int" are different, typeid(from)
should capture that information.

Oh well, the type_info class in g++ 3.3.4 doesn't capture the
constness of the object. I think it should be doing that.

Rgds,
anna

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Isaac Rodriguez · Guest

Kyung Kook Park · Guest

This compiles well in VC 7.1 (MS Visual Studio .NET 2003) and the
result I got is:
_Type &
_Type const &
as I expected.

I thought this is the same as what is called "partial specialization".
The following code is compiled well both in GCC and VC.
What is different from my previous sample code?

#include <stdio.h>

template <class T>
void foo(const T &t)
{ printf("const T &n"); }

template <class T>
void foo(T &t)
{ printf("T &n"); }

template <class T>
void foo (T *pt)
{ printf("T *n"); }

int main()
{
int n = 5;
const int &c = n;
int *p = &n;

foo( n );
foo( c );
foo( p );

return 0;
}
~

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Kyung Kook Park · Guest

If both are equally close match, why the following compiles
well in GCC and shows me the expected result ?

#include <stdio.h>

template <class T> void foo(const T &t)
{ printf("const T &n"); }

template <class T> void foo(T &t)
{ printf("T &n"); }

int main()
{
int n = 5;
const int &c = n;
foo( n );
foo( c );
return 0;
}

RESULT:
T &
const T &

~

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Kyung Kook Park · Guest

You misunderstood my question.

I know typeid() can differentiate const from non-const.
The reason I need to implement two versions is that they
will be considerably different in the real implementation.
'printf' in my sample implementation is just a test.

Thanks for the reply though.

Kyung

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

annamalai.gurusami@gmail. · Guest

Isaac Rodriguez wrote:

(snip)

annamalai.gurusami@gmail. · Guest

Kyung Kook Park wrote:

simont · Guest

I checked it on Comeau's online compiler, and it too likes the single
template parameter version, but not the two-parameter one.

Having had a quick read of the function template partial ordering and
overloading rules, I don't really see why this should be so, but using
partial specialisation of class templates instead certainly does the
trick.

Eg,
----------
#include <iostream>

// helper class
template <typename T, typename F>
struct fooHelper
{
static void foo() { std::cout << "fooHelper };

// partial specialisation
template <typename T, typename F>
struct fooHelper<T,const F>
{
static void foo() { std::cout << "fooHelper };

// single, non-overloaded function template
template <typename T, typename F>
void foo(F&)
{
fooHelper<T,F>::foo();
}

int main()
{
int n;
int& r(n);
const int& c(r);

foo<double>(n);
foo<double>(r);
foo<double>(c);
}
-----------

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

David Abrahams · Guest

"Kyung Kook Park" <kyungk (AT) gmail (DOT) com> writes:

Daveed Vandevoorde · Guest

Kyung Kook Park wrote:

Tom Widmer · Guest

Kyung Kook Park wrote:

Seungbeom Kim · Guest

[email]annamalai.gurusami (AT) gmail (DOT) com[/email] wrote: