new to Templates' concept

I just finished the templates chapter wich is covered in around 20 pages only in my C++ book. I understood it's essential concepts but i need to make some things clear :

Q1: Why would i use a template nontype parameter when i can simply add an extra argument to a function that uses that template for example?

Q2: function\class-template specilization is the object code produced that uses the same type sent to the template argument list, so if i call a function-template with int then another time with double data ; the compiler would produce 2 specilizations.

did i get it right?

Q3: Do templates go under "Polymorphism"?

Q4: Are these two template function calls different? if so , why? (arg is double) :

Code:

foo<double>(arg);

Code:

foo(arg);

Q5: whats the difference between typename and class?



appreciate your help

Q1: When the second parameter should change the type. I've had a usage before where
SomeTemplate<1> != SomeTemplate<2> and operations could not be preformed between the two.

Q2: Yep

Q3: My understanding is that polymorphism has more to do with inheritence. So the answer would be yes and no.

Q4: Test it out

Q5: spelling

I already tested those two function calls. They both worked , but i thought they might not the be exactly the same.

Thanks for the quick response Thantos.

I think every thing has been covered, although, from my understanding, typename doesn't exactly equal class. int,float,double,char are all primitives, IIRC, and not so much Classes, yet they are a type, and can also be used with templates.

In a template typename and class are the same. IMO typename is better because it covers everything and there is less confusion with using class to define well a class.

Templates can be considered as "compile time polymorphism" - they let you write the same code against multiple types. I think it's also known as "parametric polymorphism" (?).

If you have something like this:

Code:

template <typename T>
void foo(T t)
{
	cout<<"first"<<endl;

}

And call it like this

Code:

foo<double>(12.56);
	foo(12.56);

Then you basically have something like this:

Code:

	foo<double>(12.56);
00417F1E  fld         qword ptr [__real@40291eb851eb851f (4460D0h)] 
00417F24  sub         esp,8 
00417F27  fstp        qword ptr [esp] 
00417F2A  call        foo<double> (416F82h) 
00417F2F  add         esp,8 
	foo(12.56);
00417F32  fld         qword ptr [__real@40291eb851eb851f (4460D0h)] 
00417F38  sub         esp,8 
00417F3B  fstp        qword ptr [esp] 
00417F3E  call        foo<double> (416F82h) 
00417F43  add         esp,8

So these calls are same.