C / C++ / MFC

template <class T> void f (T a) { g(a); }

template <class t=""> void f (T a) { g(a); }

void g(int x) { return;}


void h()
{
	extern void g (double);	
	f (2.5);
}
</class>

George_George wrote:

extern g (double);

George_George wrote:

f (2);

George_George wrote:

Does it before g (double) is not global function or namespace scope enclosing its use? If yes, I do not know why g (double) is not a global function, since it is declared as extern and some other compile unit should expose it?

George_George wrote:

Important points are global and declaration. Right?

George_George wrote:

You like explicitly assign parameter for template function, like f <double>(2), other than f(2).

George_George wrote:

I think both declaration and definition can instantise the template function, right?

1>d:\visual studio 2008\projects\test_template3\test_template3\main.cpp(16) : error C2783: 'void f(int)' : could not deduce template argument for 'T'
1>        d:\visual studio 2008\projects\test_template3\test_template3\main.cpp(5) : see declaration of 'f'

#include <iostream>

using namespace std;

template <class T> void f(int a) {g (a);}

void g(int a)
{
	cout << a << endl;
}

extern void g(double);

int main()
{
	f (100);
	return 0;
}

George_George wrote:

I have tried similar code as yours

template <class T> void f(T a) {g (a);}

template <class T> void f(int a) {g (a);}

template <class T1, class T2> void f(T2 a) {g (a);} 

void g(int a)
{	cout << a << endl;
}

extern void g(double);

template <class T> 
void f(T a) 
{
	g (a);
}

<code>template <> 
void f(int a) 
{
	g (a);
}
or
template <> 
void f <int>(int a) 
{
	g (a);
}</code>
int main()
{	
	f (100);
	return 0;
}

template <> void f(int a) {	g (a);}

template <> void f <int>(int a) {	g (a);}

George_George wrote:

I have tried if we remove the following two functions

George_George wrote:

Seems the two specializations are useless?

template <> void f(int a) {	g (a);}

template <> void f <int>(int a) {	g (a);}

#include <iostream>

using namespace std;

void g(int a){	cout << a << endl;}

template <class T> void f(T a) {	g (a);}

// template <> void f(int a) {	g (a);}

template <> void f <int>(int a) {	g (a);}

int main()
{
	f (100);

	return 0;
}