Using implicit function template specialization to check if an identifier is an array

[Angel Tsankov]

I'm thinking about using a function tamplate to verify that an
identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

And what about using size_t instead of int?

 

[Victor Bazarov]

[ I dropped cross-posting in c.l.c++.m so the articles appear sooner]

I'm thinking about using a function tamplate to verify that an
identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

And what about using size_t instead of int?

Yes, I'd probably use 'size_t', although 'int' would work almost
as well if the size is less than INT_MAX.

Perhaps incorporating this with a compile-time assert would be
a bit better, and you could try incorporating a decent error
message into it, but should work right out of the box...

Why do you ask? Have you run into any problem with it?

V

 

[=?iso-8859-1?q?Daniel_Kr=FCgler?=]

I'm thinking about using a function tamplate to verify that an
identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

Yes, absolutely.

And what about using size_t instead of int?

Indeed size_t is the canonical type for this approach, because it is
unsigned and because every statically creatable array must have a
size expressable via sizeof, which itself returns size_t.

Greetings from Bremen,

Daniel Krügler

 

[Angel Tsankov]

[ I dropped cross-posting in c.l.c++.m so the articles appear

sooner]

I'm thinking about using a function tamplate to verify that an
identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

And what about using size_t instead of int?

Yes, I'd probably use 'size_t', although 'int' would work
almost
as well if the size is less than INT_MAX.

Perhaps incorporating this with a compile-time assert would be
a bit better,

What is your idea?

and you could try incorporating a decent error
message into it, but should work right out of the box...

Is there a standard way to incorporate an error message?

Why do you ask? Have you run into any problem with it?

No, I have not found any problems with it. I am just curious if
it is reliable, that is whether the template shall be implicitly
instantiated if and only if the argument is of an array type.

 

[Victor Bazarov]

[ I dropped cross-posting in c.l.c++.m so the articles appear
sooner]

I'm thinking about using a function tamplate to verify that an
identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

And what about using size_t instead of int?

Yes, I'd probably use 'size_t', although 'int' would work
almost
as well if the size is less than INT_MAX.

Perhaps incorporating this with a compile-time assert would be
a bit better,

What is your idea?

Check out Boost's compile-time assertions based on templates.
They have a whole bunch of them, IIRC.

Is there a standard way to incorporate an error message?

No. And it's not a simple task either. If you call your function
'check_array', and it fails, what error message do you see? Would
naming 'check_array' differently clarify it? You could try using
SFINAE mechanism to even cause something like "not an array" from
your particular compiler, I bet.

No, I have not found any problems with it. I am just curious if
it is reliable, that is whether the template shall be implicitly
instantiated if and only if the argument is of an array type.

Yes, that's certaintly so.

V

 

[Gianni Mariani]

I'm thinking about using a function tamplate to verify that an
identifier is of an array type. May the following template be used for
this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

The only change I would consider is making it so it can be used statically.

e.g.

template< typename T, unsigned N >
char (check_array_helper( T(&)[N] ))[N];

#define check_array(X) (sizeof check_array_helper(X) )


Perhaps you could eliminate the marco using somthing like this.

template< typename T>
struct check_array;

template< typename T, unsigned N >
struct check_array< T(&)[N] >
{
static const bool is_array = true;
};


Now you can use somthing like this:
check_array<var>::is_array

And what about using size_t instead of int?

Use size_t.

 

[Angel Tsankov]

I'm thinking about using a function tamplate to verify that an

identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

The only change I would consider is making it so it can be used
statically.

e.g.

template< typename T, unsigned N >
char (check_array_helper( T(&)[N] ))[N];

#define check_array(X) (sizeof check_array_helper(X) )


Perhaps you could eliminate the marco using somthing like this.

template< typename T>
struct check_array;

template< typename T, unsigned N >
struct check_array< T(&)[N] >
{
static const bool is_array = true;
};


Now you can use somthing like this:
check_array<var>::is_array

Well, one may only specify a typename or an integer as a template
argument. In fact, this is the basic difference between class
templates and function templates - function template parameters
may be deduced from the arguments to the function. Class template
parameters however, may not be deduced.

 

[Greg]

I'm thinking about using a function tamplate to verify that an
identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

How do you envision using the check_array() function template to a test
for an array type exactly? If anything, std::tr1::is_array (or
std::is_array in the future) is pretty easy to use:

#include <tr1/type_traits>

char a[30];

using std::tr1::is_array;

static bool b = is_array<a>::value;

Greg

 

[Gianni Mariani]

Angel Tsankov wrote:
....

Well, one may only specify a typename or an integer as a template
argument. In fact, this is the basic difference between class templates
and function templates - function template parameters may be deduced
from the arguments to the function. Class template parameters however,
may not be deduced.

Yep - I don't know what I was thinking...

 

[Gianni Mariani]

I'm thinking about using a function tamplate to verify that an
identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

How do you envision using the check_array() function template to a test
for an array type exactly? If anything, std::tr1::is_array (or
std::is_array in the future) is pretty easy to use:

#include <tr1/type_traits>

char a[30];

using std::tr1::is_array;

static bool b = is_array<a>::value;

Greg

Only works for variables with external linkage.

 

[Angel Tsankov]

I'm thinking about using a function tamplate to verify that

an
identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

How do you envision using the check_array() function template
to a test
for an array type exactly? If anything, std::tr1::is_array (or
std::is_array in the future) is pretty easy to use:

Where can I get an implementation of tr1?

 

[Greg]

I'm thinking about using a function tamplate to verify that an
identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

How do you envision using the check_array function template to test for
an array type? I think std::tr1::is_array would probably be more
convenient:

#include <iostream>
#include <ios>
#include <tr1/type_traits>

using std::tr1::is_array;

int main()
{
bool b = is_array< int[5] >::value;

std::cout << std::boolalpha << b << "\n";
}

Program Output:

true

Greg

 

[Angel Tsankov]

I'm thinking about using a function tamplate to verify that an

identifier is of an array type. May the following template be
used for this purpose:

template< typename T, int N >
void check_array( T(&)[N] )
{
}

How do you envision using the check_array function template to
test for
an array type? I think std::tr1::is_array would probably be
more
convenient:

#include <iostream>
#include <ios>
#include <tr1/type_traits>

using std::tr1::is_array;

int main()
{
bool b = is_array< int[5] >::value;

std::cout << std::boolalpha << b << "\n";
}

Program Output:

true

Can one use std::tr1::is_array with array, e.g.:

int array[5];
bool const b = std::tr1::is_array<array>::value;