Различное поведение функции для массивов и указателей

Question

Я пытаюсь разработать функцию с различным поведением для массивов и указателей. Это может быть достигнуто для классов по частичной специализации, но это не работает с функциями!

int i = 0; 
some_func(&i); // pointer 
int arr[ 3 ] = { 0 }; 
some_func(arr); // array 

Во втором случае внутри функции some_func типа параметра является int*, и нет никакого способа узнать, что это на самом деле int[3].

С другой стороны, если я использую класс специализации шаблона, я должен был бы указать массив типа явно:

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 

Сейчас я решила проблему с макро определить (чтобы быть точным, я нужен только точный sizeof для массивов).

Есть ли способ решить эту проблему, не обращаясь к темной стороне макроопределений?

Answer 1

Здесь я использую C++ 11 стиль программирования в C++ 03, чтобы сделать SFINAE и отправить свои массивы на одной перегрузки, и не-массивов на другой:

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

Answer 2

Возьмите массив by reference:

template< typename T > 
void some_func(T *t) { ... } 

template< typename T, size_t N > 
void some_func(T (&t)[ N ]) { ... }