Function template specialization.

**msh** · 07-21-2009

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

**laserlight** · 07-21-2009

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);

**msh** · 07-21-2009

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.

**laserlight** · 07-21-2009

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);

**msh** · 07-21-2009

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"
};

**Kudose** · 07-21-2009

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;
}

**msh** · 07-21-2009

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;
}

**tabstop** · 07-21-2009

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[]).

**Elysia** · 07-21-2009

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*.)

**msh** · 07-22-2009

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.

**Elysia** · 07-22-2009

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).

**CornedBee** · 07-22-2009

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

**linuxdude** · 07-22-2009

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?

**laserlight** · 07-22-2009

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.

**Elysia** · 07-22-2009

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...

Thread: Function template specialization.

Thread Tools

Search Thread

Display

Function template specialization.

Similar Threads

Game Pointer Trouble?

<Gulp>

Post...

Dikumud

C++ compilation issues

Tags for this Thread