problem with explicit template instantiation in Visual C++ 6.0 .

[C. Carbonera]

/*
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 DummyFunctionDo esNotWork(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 DummyFunctionWo rks(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 DummyFunctionWo rks(T &o)
{ cout << o() << endl; }

template < typename T >
void DummyFunctionDo esNotWork()
{ 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;
DummyFunctionWo rks < Dummy< first_t > > ( frst );
DummyFunctionWo rks < Dummy< second_t > > ( scnd );

cout<< "The following produces the wrong output:" << endl;
DummyFunctionDo esNotWork < Dummy < first_t > > ( );
DummyFunctionDo esNotWork < Dummy < second_t > > ( );
}

[AirPete]

C. Carbonera wrote:

/* [snip]
Could someone please test the code given below in Visual C++.NET
and let me know if it works?
It work in VC++ 2003 with a few minor modifications to include the correct
header:

Thanks,
CCarbonera
*/
#include <fstream.h>
#include <fstream>
using namespace std;

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 DummyFunctionWo rks(T &o)
{ cout << o() << endl; }

template < typename T >
void DummyFunctionDo esNotWork()
{ 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;
DummyFunctionWo rks < Dummy< first_t > > ( frst );
DummyFunctionWo rks < Dummy< second_t > > ( scnd );

cout<< "The following produces the wrong output:" << endl;
DummyFunctionDo esNotWork < Dummy < first_t > > ( );
DummyFunctionDo esNotWork < Dummy < second_t > > ( );
}

[AirPete]

[snip]

#include <fstream>
Sorry, this should be <iostream> , not <fstream> .
using namespace std;

[snip

[Jonathan Turkanis]

"C. Carbonera" <cc********@msn .com> wrote in message
news:df******** *************** ***@posting.goo gle.com...

/*
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 DummyFunctionDo esNotWork(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 DummyFunctionWo rks(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 DummyFunctionWo rks(T &o)
{ cout << o() << endl; }

template < typename T >
void DummyFunctionDo esNotWork()
{ 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;
DummyFunctionWo rks < Dummy< first_t > > ( frst );
DummyFunctionWo rks < Dummy< second_t > > ( scnd );

cout<< "The following produces the wrong output:" << endl;
DummyFunctionDo esNotWork < Dummy < first_t > > ( );
DummyFunctionDo esNotWork < 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

[C. Carbonera]

"Jonathan Turkanis" <te******@kanga roologic.com> wrote in message news:<bv******* *****@ID-216073.news.uni-berlin.de>...

"C. Carbonera" <cc********@msn .com> wrote in message
news:df******** *************** ***@posting.goo gle.com...

/*
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 DummyFunctionDo esNotWork(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 DummyFunctionWo rks(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 DummyFunctionWo rks(T &o)
{ cout << o() << endl; }

template < typename T >
void DummyFunctionDo esNotWork()
{ 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;
DummyFunctionWo rks < Dummy< first_t > > ( frst );
DummyFunctionWo rks < Dummy< second_t > > ( scnd );

cout<< "The following produces the wrong output:" << endl;
DummyFunctionDo esNotWork < Dummy < first_t > > ( );
DummyFunctionDo esNotWork < 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 DummyFunctionDo esNotWork < Dummy < first_t > > ( ) and
void DummyFunctionDo esNotWork < 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()(voi d) { return "First
Function"; }

template<>
const char* Dummy<second_t> ::operator()(vo id) { 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> >();
}