By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
448,679 Members | 1,063 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 448,679 IT Pros & Developers. It's quick & easy.

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

P: n/a
/*
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 > > ( );
}
Jul 22 '05 #1
Share this Question
Share on Google+
4 Replies


P: n/a
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 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 > > ( );
}


Jul 22 '05 #2

P: n/a
[snip]

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

[snip
Jul 22 '05 #3

P: n/a

"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
Jul 22 '05 #4

P: n/a
"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> >();
}
Jul 22 '05 #5

This discussion thread is closed

Replies have been disabled for this discussion.