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 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 >:perator()(){ return " First Type "; }

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

 

[AirPete]

/* [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>


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 >:perator()(){ return " First Type "; }

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

 

[AirPete]

[snip]

#include <fstream>

using namespace std;

[snip

 

[Jonathan Turkanis]

/*
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 >:perator()(){ return " First Type "; }

template <>
const char* Dummy<second_t>:perator()(){ 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

 

[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 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 >:perator()(){ return " First Type "; }

template <>
const char* Dummy<second_t>:perator()(){ 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 >:perator()() and
const char* Dummy< second_t >:perator()()
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>:perator()(void) { return "First
Function"; }

template<>
const char* Dummy<second_t>:perator()(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> >();
}