function template

[nimitzhunter]

Hi all,
I have a few points about function template that I need to clear up. So i have this array in main.

double *array;

And I want to pass that one into a function template.

// version 1
template<class Type>
void sort(Type & A, int length)
//version 2
template<class Type>
void sort(Type * A, int length)

If i use the version 1 to declare the template, sort(array,length). that would make A a reference to double *, and Type=double *.
If i use version 2 , then A is a pointer to type double, and Type = double.
I tested out both template, and they both worked. But I want to ask you guys's opnions of which version is a better coding practice? or are they the same as long as I use Type consistently in the function body?

One more point that I am kind of confused is that if I use an explicit specialization for the function template, wouldn't it be the same as using a nontemplate function?

[whiteflags]

I think calling sort<double*>(array, n); given the real type of array, uses a different type for no reason. A pointer is already a pass-by-reference type, which is all you could gain from the overloaded functions.

Template specialization is important for when certain template arguments mean the template code itself needs to be different.

[nimitzhunter]

Thanks whiteflags.

[Nextstopearth]

Since array is double * in both cases, how does Type end up being double in version 2?

[laserlight]

Since array is double * in both cases, how does Type end up being double in version 2?

For version 2, the first parameter is of type Type*. Therefore, if the corresponding argument is of type double*, it follows that Type is double.

[Nextstopearth]

For version 2, the first parameter is of type Type*. Therefore, if the corresponding argument is of type double*, it follows that Type is double.

I am confused then. If Type is double *, and we have Type *A, it seems like A would be a double **.

[laserlight]

If Type is double *, and we have Type *A, it seems like A would be a double **.

Yes, hence Type is double, not double*.

[Nextstopearth]

Yes, hence Type is double, not double*.

That doesn't help me...I know Type is supposed to be double. I just don't see why. Again, if you are sending a double * as an argument, and then declaring a pointer to that, how is A not a pointer to a double *?

[laserlight]

That doesn't help me...I know Type is supposed to be double. I just don't see why. Again, if you are sending a double * as an argument, and then declaring a pointer to that, how is A not a pointer to a double *?

Looking only at version 2 of the function template, what is the type of the parameter A?

[nimitzhunter]

I think since "array" is a pointer to double, when you pass into the function, A becomes a pointer to double. Thus that makes Type = double. doesn't template look at the argument before specialization?

[grumpy]

You want to pass a double * to your version 2 template function with this signature

template<class Type> sort(Type *, int);

This means the sort() function, obtained by instantiating your version 2 template, must accept a double * as first argument. For "Type *" and "double *" to be the same type, Type must be double.

[Nextstopearth]

Looking only at version 2 of the function template, what is the type of the parameter A?

Type *

[laserlight]

Type *

Indeed. So if A is of type Type*, and if array is of type double*, then Type is double. This is extremely simple pattern matching.

Using your language: if you are sending a double* as an argument, and then declaring a pointer to a type named Type, then Type must be a double. It cannot possibly be a double*, because you are declaring a pointer to Type, not a value or reference of type Type.

[Nextstopearth]

Indeed. So if A is of type Type*, and if array is of type double*, then Type is double. This is extremely simple pattern matching.

Using your language: if you are sending a double* as an argument, and then declaring a pointer to a type named Type, then Type must be a double. It cannot possibly be a double*, because you are declaring a pointer to Type, not a value or reference of type Type.

Well apparently there are things going on here that I am not aware of. For example:

template <typename T>
void func(T arg);

If you call func with

func(3);

You just replace T with the type of the argument, which would be int. In the other example in this thread you don't just replace the template parameter with the exact type of the actual argument, something more happens. I didn't know that.

[laserlight]

In the other example in this thread you don't just replace the template parameter with the exact type of the actual argument, something more happens.

Yes. Let's consider this again:

template <typename T>
void func(T arg);

Now, you write:

double* p;
func(p);

So, T is double*. But now we change it to:

template <typename T>
void func(T* arg);

If T is still double*, then it follows that the * has changed nothing. In other words, using your reasoning, this:

template <typename T>
void func(T arg);

and this:

template <typename T>
void func(T**************************************** arg);

still result in T being of type double* if the argument is of type double*. Does that make sense to you? It does not make sense to me.