Re: question on function template

From:

"Daniel T." <daniel_t@earthlink.net>

Newsgroups:

comp.lang.c++

Date:

Fri, 04 Jan 2008 12:54:22 -0500

Message-ID:

<daniel_t-A740B1.12542004012008@earthlink.vsrv-sjc.supernews.net>

"subramanian100in@yahoo.com, India" <subramanian100in@yahoo.com>
wrote:

consider the following program:

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include <list>

using namespace std;

template<typename T> void fn(T const & arg)
{
        cout << "from fn: " << sizeof(arg) << endl;
        return;
}

template<typename T> void g(const vector<T>& arg)
{
        cout << "from g: " << sizeof(T) << " "
               << sizeof(arg) << endl;
        return;
}

int main()
{
        vector<int> vi;
        fn(vi);

        list<string> ls;
        fn(ls);

        g(vi);

        vector<long double> vld;
        g(vld);

        return EXIT_SUCCESS;
}

When fn() is called with 'vi' and 'ls', the parameter types deduced
for 'T' in fn() are 'vector<int>' and 'list<string>' respectively -
that is 'vector<int>' and 'list<string>' get substituted for 'T' in
fn(). However, when g() is called with 'vi' and 'vld', the parameter
types deduced for 'T' in g() are 'int' and 'long double' respectively
- that is, 'vector<int>' and 'vector<long double>' are NOT substituted
for 'T' in g().

I thought when g() is called with 'vi' ie 'g(vi)' would instantiate
void g(const vector< vector<int> > &arg) and when g() is called with
'vld' ie 'g(vld)' would instantiate void g(const vector< vector<long
double> > & arg). But it doesn't seem to be the case.

I am unable to understand the difference between the function template
argument deduction for fn() and g(). Kindly explain.

I don't see where your issue has been adequately explained, and frankly
I'm not sure what the explanation is.

I suspect that the compiler tries to match the parameter as best as
possible before making any substitutions. Note, for example, what the
compiler does if you make both function names the same...

template<typename T> void fn(T const & arg)
{
        cout << "from fn: " << sizeof(arg) << endl;
        return;
}

template<typename T> void fn(const vector<T>& arg)
{
        cout << "from g: " << sizeof(T) << " "
               << sizeof(arg) << endl;
        return;
}

int main()
{
        vector<int> vi;
        fn(vi);

        list<string> ls;
        fn(ls);

        fn(vi);

        vector<long double> vld;
        fn(vld);

        return EXIT_SUCCESS;
}

In this case, the second function is called for any vector. The first
function is only called if the parameter is not a vector.