Nontype template parameter

[felipe21]

Hi guys, why doesn't this code compile?

template <class T, size_t N> 
       void array_init(T parm[N])
{ /*...*/ }

but this one does:

template <class T, size_t N> 
       void array_init(T (&parm)[N])
{ /*...*/ }

Thanks in advance.

[guestgulkan]

What error are you getting?

The following compiles on mingw and msvc
(note that I include iostream to make sure that size_t is properly declared)

#include <iostream>

 template <class T, size_t N> 
       void array_init(T parm[N])
{ /*...*/ } 


template <class T, size_t N> 
       void array_init(T (&parm)[N])
{ /*...*/ }


int main()
{
    
  int my_array[5];  //array
  
  int (&ref_array)[5] = my_array; //reference to an array
  
  array_init ( my_array);
  array_init(ref_array);


}

[guestgulkan]

Oh, my mistake.
The code I posted does compile - BUT both calls at line 20 and 21 are using the second template void array_init(T (&parm)[N]).

If you have this:

#include <iostream>

template <class T, size_t N> 
       void array_init(T parm[N])
{ /*...*/ } 


int main()
{  
  int my_array[5];  //array  
  
  array_init ( my_array);
}

then it does not work, because in C/C++ when you think you are passing an array, you are actually passing a pointer.

So this actually works:

#include <iostream>

template <class T> 
       void array_init(T*)
{ /*...*/ } 


int main()
{  
  int my_array[5];  //array  
  
  array_init ( my_array);
}

[felipe21]

Thanks for your replies

then it does not work, because in C/C++ when you think you are passing an array, you are actually passing a pointer.

How does this work then?

#include <iostream>
using namespace std;

void array_init2(int parm[])
{ /*...*/ }

int main()
{
  int my_array[5];  //array

  array_init2( my_array);
}

Couldn't be that the template has some restriction or something?

by the way, the error I get is:

error: no matching function for call to ‘array_init(int [5])’

[guestgulkan]

that code works as I say because in C/C++ when you pass an array you are passing a pointer, and the array_init2 is defined as taking an int array - but it will actually be getting a pointer (although inside the function you treat it exactly as an array)

because it is a pointer being passed, the following is also equivalant:

void array_init2(int* parm)
{ /*...*/ }

int main()
{
  int my_array[5];  //array

  array_init2( my_array);
}

C/C++ does not pass arrays by copy - it is one of those C/C++ things.

That is why you are getting the error: no matching function for call to ‘array_init(int [5])’ error - templates are somwehat more strict (you could possibly use a typedef as a workaround)

[felipe21]

templates are somewhat more strict

Are you saying that this conversion that occurs from the name of an array
to a pointer in a regular function is an error with templates? Because it looks like it.
I reduced my code to the working minimum and this is what I got:

#include <iostream>
using namespace std;

void func(int arr[])
{
    cout << "yuhuu" << endl;
}

int main()
{
	int arr[10];
	func(arr); // fine prints "yuhuu" on screen
	return 0;
}

now with only one extra line

#include <iostream>
using namespace std;

template <class T> // only line added
void func(int arr[])
{
    cout << "yuhuu" << endl;
}

int main()
{
	int arr[10];
	func(arr); // error:  no matching function for call to ‘func(int [10])
	return 0;
}

[jsmith]

func<int>(arr );

works in that case.

[fetag]

You can try like this:

#include <iostream>

template <typename T, int SIZE>
void array_int(T*& parm)
{
	parm = new T[SIZE];
	strcpy(parm, "hello");
}

int main()
{
	char* ptr;
	array_int<char, 10>(ptr);
	std::cout << ptr << std::endl;
	delete [] ptr;
	return 0;
}

[fetag]

you can not pass a array to a function, no matter it is a NORMAL function or a template

function, just pass a pointer to the function, then tell it the size of the array. In this place, the

size is just the Nontype template parameter.