"Jonathan Turkanis" <te******@kangaroologic.com> wrote in message news:<bv************@ID-216073.news.uni-berlin.de>...
"C. Carbonera" <cc********@msn.com> wrote in message
news:df**************************@posting.google.c om... /*
Hi,
I have a problem with explicit instantiation of templates in Visual
C++ 6.0.
I have provided the source below. I have an example of a function
template that produces incorrect output in the code below.
The function
template < typename T >
void DummyFunctionDoesNotWork(T &o);
Produces incorrect output. The following is the expected output:
First Type
Second Type
But, instead, I obtain the following is the output:
Second Type
Second Type
I have written a second function
template < typename T >
void DummyFunctionWorks(T &o);
That produces the correct output.
Could someone please test the code given below in Visual C++.NET
and let me know if it works?
Thanks,
CCarbonera
*/
#include <fstream.h>
enum explicit_t
{first_t=1,
second_t=0};
template <explicit_t t>
struct Dummy
{
const char* operator()(void){ return " UNDEFINED "; };
};
template <>
const char* Dummy< first_t >::operator()(){ return " First Type "; }
template <>
const char* Dummy<second_t>::operator()(){ return " Second Type "; }
template < typename T >
void DummyFunctionWorks(T &o)
{ cout << o() << endl; }
template < typename T >
void DummyFunctionDoesNotWork()
{ T o; cout << o() << endl; }
void main(int argc, char* argv[])
{
cout<< "The following produces the correct output:" << endl;
Dummy<first_t> frst;
Dummy<second_t> scnd;
DummyFunctionWorks < Dummy< first_t > > ( frst );
DummyFunctionWorks < Dummy< second_t > > ( scnd );
cout<< "The following produces the wrong output:" << endl;
DummyFunctionDoesNotWork < Dummy < first_t > > ( );
DummyFunctionDoesNotWork < Dummy < second_t > > ( );
}
This is a very funny bug! Have you tried reversing the last two lines?
I get:
First Type
First Type
Both calls are resolved differently, juist because they are invoked in
a different order.
(By the way, you are really talking about explicit specializaion, not
explicit instantiation. Also main returns int, ... )
Jonathan
Jonathan,
Thank you for your feedback.
I have one comment. The problem occurs when the functions
void DummyFunctionDoesNotWork < Dummy < first_t > > ( ) and
void DummyFunctionDoesNotWork < Dummy < second_t > > ( ) are
instantiated;
hence, I labeled the problem as an eplicit instantiation.
There explicit specializations of the functions
const char* Dummy< first_t >::operator()() and
const char* Dummy< second_t >::operator()()
work well as the example below illustrates.
/*
Please, turn on and off the compiler directive '#define WORKS' below
to compare the results.
*/
#include <iostream>
using namespace std;
enum explicit_t
{
first_t=1,
second_t=0
};
template <explicit_t t>
struct Dummy{ virtual const char* operator()(void){ return NULL; };
};
template<>
const char* Dummy<first_t>::operator()(void) { return "First
Function"; }
template<>
const char* Dummy<second_t>::operator()(void) { return "Second
Function"; }
//#define WORKS
#ifdef WORKS
template <typename T>
void DummyFunction(T o = T())
{
cout << T()() << endl;
}
#else
template <typename T>
void DummyFunction( )
{
T o;
cout << o() << endl;
}
#endif
void main(void)
{
DummyFunction< Dummy<first_t> >();
DummyFunction< Dummy<second_t> >();
}