regarding templates

[sam_cit]

Hi Everyone,

Its know that c++ compiler instantiates a new version of the
function/class when it sees a usage of a function/class template with a
particular data type, assuming that c++ supports 10 data types, how
many versions of the function template would be created for the
following example?

template <class T>
T sample(T value)
{
return T * T;
}

int main()
{
int i=5;
sample(i);
}

Would the compiler create one version of the function to handle int
data type or as many versions as many as the number of data types that
c++ supports?

[Victor Bazarov]

sa*****@yahoo.co.in wrote:

Its know that c++ compiler instantiates a new version of the
function/class when it sees a usage of a function/class template with
a particular data type, assuming that c++ supports 10 data types, how
many versions of the function template would be created for the
following example?

template <class T>
T sample(T value)
{
return T * T;
}

int main()
{
int i=5;
sample(i);
}

Would the compiler create one version of the function to handle int
data type or as many versions as many as the number of data types that
c++ supports?

How many times 'sample' is *used*? How many different types in all
uses of 'sample' are there? Figure that out, and you will have figured
the number of template instantiations.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Clark S. Cox III]

sa*****@yahoo.co.in wrote:

Hi Everyone,

Its know that c++ compiler instantiates a new version of the
function/class when it sees a usage of a function/class template with a
particular data type, assuming that c++ supports 10 data types,

C++ supports an (effectively) infinite number of data types.

how
many versions of the function template would be created for the
following example?

template <class T>
T sample(T value)
{
return T * T;

I assume that you meant:
return value * value;

}

int main()
{
int i=5;
sample(i);
}

Would the compiler create one version of the function to handle int
data type or as many versions as many as the number of data types that
c++ supports?

As you stated above: "Its know [sic] that c++ compiler instantiates a
new version of the function/class when it sees a usage of a
function/class template with a particular data type", so your answer is:
one.
--
Clark S. Cox III
cl*******@gmail.com

[mlimber]

[e-mail] wrote:

Its know that c++ compiler instantiates a new version of the
function/class when it sees a usage of a function/class template with a
particular data type, assuming that c++ supports 10 data types, how
many versions of the function template would be created for the
following example?

template <class T>
T sample(T value)
{
return T * T;
}

int main()
{
int i=5;
sample(i);
}

Would the compiler create one version of the function to handle int
data type or as many versions as many as the number of data types that
c++ supports?

Only the ones you use. Moreover, it could also instantiate that
template (assuming you fix the syntax errors) for user defined types,
not just built-in types:

class X { /*...*/ };
X operator( const X& x1, const X& x2 ); // defined somewhere

int main()
{
sample( 5 ); // Invoke sample<int>()
sample( 5.0 ); // Invoke sample<double>()
X x;
sample( x ); // Invoke sample<X>()
}

Cheers! --M

[h.yuzhao]

Template is object-level programming, that means only when the
compliler need to generate objects templatelized, such as class object,
function object.., by template, the versions(as you said) should be
created by the compliler accordingly.
So, how many distinct date types you passed to function template, how
many versions created!
"sa*****@yahoo.co.in дµÀ£º
"

Hi Everyone,

Its know that c++ compiler instantiates a new version of the
function/class when it sees a usage of a function/class template with a
particular data type, assuming that c++ supports 10 data types, how
many versions of the function template would be created for the
following example?

template <class T>
T sample(T value)
{
return T * T;
}

int main()
{
int i=5;
sample(i);
}

Would the compiler create one version of the function to handle int
data type or as many versions as many as the number of data types that
c++ supports?

[Salt_Peter]

sa*****@yahoo.co.in wrote:

Hi Everyone,

Its know that c++ compiler instantiates a new version of the
function/class when it sees a usage of a function/class template with a
particular data type, assuming that c++ supports 10 data types, how
many versions of the function template would be created for the
following example?

template <class T>
T sample(T value)
{
return T * T;
}

int main()
{
int i=5;
sample(i);
}

Would the compiler create one version of the function to handle int
data type or as many versions as many as the number of data types that
c++ supports?

The compiler only generates a version per type used. And you should use
references instead of returns specially if you plan to ignore returns.

#include <iostream>
#include <ostream>

template< class T >
void square(T& value)
{
value *= value;
}

int main()
{
int n = 5;
square(n);
std::cout << "n = " << n << std::endl;
}

/*
n = 25
*/