Different behaviour of function for arrays and pointers - c++

Question

I'm trying to develop a function with different behaviour for arrays and pointers.
It could be achieved for classes by partial specialization, but it doesn't work on functions!
int i = 0;
some_func( &i ); // pointer
int arr[ 3 ] = { 0 };
some_func( arr ); // array
In second case inside of function some_func parameter type is int*, and there is no way to find out, that it's actually int[3].
On the other hand, if I use class template specialization, I'd have to specify array type explicitly:
template< typename T >
struct S
{
static void some_func( T t ) { ... }
};
template< typename T, size_t N >
struct S< T[ N ] >
{
static void some_func( T t[ N ] ) { ... }
};
// ...............
int arr[ 3 ] = { 0 };
S< int[ 3 ] >::some_func( arr ); // Works,
// but specifying type explicitly is not convenient
For now I've solved the problem with macro define (to be precise, I only need precise sizeof for arrays).
Is there any way to solve it without turning to the dark side of macro definitions?

Answer 1

Take the array by reference:
template< typename T >
void some_func( T *t ) { ... }
template< typename T, size_t N >
void some_func( T (&t)[ N ] ) { ... }

Answer 2

Here I use C++11 style programming in C++03 to do SFINAE and send my arrays at one overload, and non-arrays at another:
#include <iostream>
struct false_type { enum { value = false }; };
struct true_type { enum { value = true }; };
template<typename T>
struct is_array:false_type {};
template<typename T, std::size_t N>
struct is_array<T[N]>:true_type {};
template<bool b,typename T=void>
struct enable_if {};
template<typename T>
struct enable_if<true, T> { typedef T type; };
template<typename T>
typename enable_if< is_array<T>::value>::type some_func( T& array, int unused=0 )
{
std::cout << "array\n";
}
template<typename T>
typename enable_if< !is_array<T>::value>::type some_func( T const& not_array )
{
std::cout << "pointer\n";
}
int main() {
int x[3];
some_func( x );
int y;
some_func( &y );
}