Function template specialization.

I'm trying to get my head around function template specializations and I just can't understand what am I doing wrong here.

Prototypes and error below.

Can someone explain to me what I'm doing wrong?

Code:

// template
template <typename T>
T findMax(const T arr[], int n);

// specializations for char**
template <>
char* findMax(const char* arr[], int n);

I get the following error from GCC:

Code:

error: template-id 'findMax<>' for 'char* findMax(const char**, int)' does not match any template declaration

It should be:

Code:

// specializations for char*
template <>
char* findMax(char* const arr[], int n);

since the const is supposed to be applied to T, hence it is applied to char*, not char. If you really want to specialise for char**, then it should be:

Code:

// specializations for char**
template <>
char** findMax(char** const arr[], int n);

Ah. I see!

It's different from regular functions, e.g:

Code:

void f(const char arr[]);

Could you elaborate some more why it is so? It seems somewhat unintuitive.

Originally Posted by msh

It's different from regular functions

Different? If you are talking about what the const in the parameter applies to, then no, that is not true. For the parameter of f, the const applies to the char, not the pointer. Perhaps it would be easier to see if we rewrote it as:

Code:

void f(const char* arr);

or:

Code:

void f(char const* arr);

Okay. I'm lost now.

That still does not work as I want it to, that is, I want the specialization to process something like this:

Code:

const char* s[5] =
{
    "London",
    "Berlin",
    "Paris",
    "Madrid",
    "Lisbon"
};

You are declaring a pointer array in which the elements are 5 characters(?) long.

Code:

#include<stdlib.h>

int main(){

  const char* cities[10] = { "London", "Paris", "NYC" };

  printf("%s", *(cities + 1)); // prints Paris

  system("PAUSE");
  return 0;
}

I was under the impression that I'm declaring an array of 5 pointers to string constants.

Code:

int main(void) {
    
    const char* s[5] = 
    {
        "London",
        "Berlin",
        "Paris",
        "Madrid",
        "Lisbon"
    };
    
    for (int i = 0; i < 5; i++) {
        std::cout << s[i] << std::endl;
    }
    
    return 0;
}

Originally Posted by msh

I was under the impression that I'm declaring an array of 5 pointers to string constants.

Code:

int main(void) {
    
    const char* s[5] = 
    {
        "London",
        "Berlin",
        "Paris",
        "Madrid",
        "Lisbon"
    };
    
    for (int i = 0; i < 5; i++) {
        std::cout << s[i] << std::endl;
    }
    
    return 0;
}

I'm with you -- five pointers to string constants.

If this is supposed to match your function definition thing, well, it doesn't. The const here refers to the fact that your strings are constants; the const in your function declaration says that the array won't be changed (i.e., it's a char * const arr[]).

Originally Posted by msh

I was under the impression that I'm declaring an array of 5 pointers to string constants.

That's right. You're defining an array of 5 elements of type const char* (pointer to const char, not const pointer to char).
(Although your function wants a constant POINTER to char*.)

Well. I managed to sort it out. Apparently, I was, as they say on the Internet, doing it wrong.

Code:

template <typename T> T findMax(T arr[], int n);

template <> const char* findMax(const char* arr[], int n);

This works as I want it to, albeit I'm still unsure about the whole specialization thing.

As explained, it has nothing to do with specialization and everything to do with you using the improper types.
const char* arr[] -> Arrays of pointers to const char.
const char** arr -> Pointers to pointers to const char (can also be seen as an array of pointers to const char).
char* const arr[] -> Constant array of pointers to char.
char** const arr -> Constant pointers to pointers to char (can also be seen as a constant array of pointers to char).

By the way, usually overloading functions is better than specializing them.

Originally Posted by CornedBee

By the way, usually overloading functions is better than specializing them.

I'm confused by what you mean here? If you have a template, then you will specialize functions. If you don't then you can overload them. Could you be more elaborate?

Originally Posted by linuxdude

I'm confused by what you mean here? If you have a template, then you will specialize functions. If you don't then you can overload them. Could you be more elaborate?

You can overload even when a function template is involved.

Code:

template<typename T> T func();
template<typename T> T func(T);
template<typename T> T func(T, T);
template<typename T, typename T2> T func();
template<typename T, typename T2> T func(T2);
template<typename T, typename T2> T func(T2, T2);

Overloading...