typedef char    YES;
struct NO {char size[2];};

template<typename T_> struct is_array_
{
  template <typename U_> static NO is(U_* const*);
  static YES is(...);
  static T_* ret();
  enum { value = sizeof( is(ret()) ) == sizeof(YES)  };
};

template<typename T> struct is_array
{
  static YES is(const void*);
  static NO is(...);
  static T& ret(); 
  enum { value = sizeof( is(ret()) ) == sizeof(YES) && is_array_<T>::value };
};

template<> struct is_array<void>
{
  enum { value = 0 };
};

D> Предлагаю сделать читабельней

template < typename T > struct test_array
{
private:
  typedef char NO;
  typedef struct { NO _[2]; } YES;
  enum { yes = sizeof(YES) };
  
  template < class U > static NO is1(U* const*);
  static YES is1(...);
  static T* ret1();
  
  static YES is2(const void*);
  static NO is2(...);
  static T& ret2();

public:
  enum { is_not_pointer  = sizeof(is1(ret1())) == yes };
  enum { is_pointer_like = sizeof(is2(ret2())) == yes };
  
  enum { is_array = is_not_pointer && is_pointer_like };
};

К>И еще читабельнее

К>  static T& ret2();
К>

template<> struct test_array<void>
{
  enum { value = 0 };
};

static T_& ret();

is_array<int[]>::value

template <class T>
 struct Type2Type {
        typedef T OriginalType;
        Type2Type() {};
 };

template<class T1, class T2>
class TypeIdentity {

    template<class TT>
        struct compilerCompare_ {
        enum {flag = 0};
        };

    template<>
        struct compilerCompare_<T2> {
        enum {flag = 1};
        };

public:
    enum { equal = (TypeIdentity<T1, T2>::compilerCompare_<T1>::flag == 1) };

};

D>static T_& ret(); 
D>

D>is_array<int[]>::value
D>

template<typename T_> struct is_array
{
  static char (&is(const void*))[2];
  static char (&is(...))[1];
  static T_* ret(); 
  enum { value = (sizeof(is(*ret())) - 1) && is_array_<T_>::value };
};

АТ>template<typename T_> struct is_array_
АТ>{
АТ>  template <typename U_> static char (&is(U_* const*))[1];
АТ>  static char (&is(...))[2];
АТ>  static T_* ret();
АТ>  enum { value = sizeof(is(ret())) - 1 };
АТ>};
АТ>

АТ>template<typename T_> struct is_array
АТ>{
АТ>  static char (&is(const void*))[2];
АТ>  static char (&is(...))[1];
АТ>  static T_& ret(); 
АТ>  enum { value = (sizeof(is(ret())) - 1) && is_array_<T_>::value };
АТ>};

АТ>template<> struct is_array<void>
АТ>{
АТ>  enum { value = 0 };
АТ>};
АТ>

template<class P>
struct Crafty
{
    operator P*() { return 0; }
};

template<>
struct Crafty<bool>
{
};

typedef Crafty<bool> Crafty1;
typedef Crafty<void> Crafty2;
typedef Crafty<int> Crafty3;

typedef Crafty1 CRAFTIES[2];

int _tmain(int argc, _TCHAR* argv[])
{
    cout << is_array<Crafty1>::value << endl;
    cout << is_array<Crafty2>::value << endl;
    cout << is_array<Crafty3>::value << endl;
    cout << is_array<CRAFTIES>::value << endl;
    return 0xDead;
}

struct PointerShim
{
  PointerShim(const volatile void*);
};

template<typename T_> struct is_array_
{
  template <typename U_>
  static char (&is(U_* const*))[1];

  static char (&is(...))[2];
  static T_* ret();

  enum { value = sizeof(is(ret())) - 1 };
};

template<typename T_> struct is_array
{
  static char (&is(PointerShim))[2];
  static char (&is(...))[1];
  static T_& ret(); 

  enum { value = (sizeof(is(ret())) - 1) && is_array_<T_>::value };
};

template<> struct is_array<void>
{
  enum { value = 0 };
};

template<class P>
struct Crafty
{
    operator P*() { return 0; }
};

template<>
struct Crafty<bool>
{
};

typedef Crafty<bool> Crafty1;
typedef Crafty<void> Crafty2;
typedef Crafty<int>  Crafty3;

typedef Crafty1 CRAFTIES[2];

int main()
{
  using namespace std;
  cout << is_array<Crafty1>::value << endl;
  cout << is_array<Crafty2>::value << endl;
  cout << is_array<Crafty3>::value << endl;
  cout << is_array<CRAFTIES>::value << endl;
  return 0;
}

0
0
0
1

Borland C++ 5.6 for Win32 Copyright (c) 1993, 2002 Borland
isarr.cpp:
Error E2034 isarr.cpp 25: Cannot convert 'Crafty1' to 'PointerShim' in function main()
Error E2340 isarr.cpp 25: Type mismatch in parameter 1 (wanted 'PointerShim', got 'Crafty1') in function main()
Error E2285 isarr.cpp 16: Could not find a match for 'is_array_<Crafty1>::is<U_>(Crafty1 *)' in function main()
Error E2109 isarr.cpp 16: Not an allowed type in function main()
Error E2034 isarr.cpp 25: Cannot convert 'Crafty2' to 'PointerShim' in function main()
Error E2340 isarr.cpp 25: Type mismatch in parameter 1 (wanted 'PointerShim', got 'Crafty2') in function main()
Error E2285 isarr.cpp 16: Could not find a match for 'is_array_<Crafty2>::is<U_>(Crafty2 *)' in function main()
Error E2109 isarr.cpp 16: Not an allowed type in function main()
Error E2034 isarr.cpp 25: Cannot convert 'Crafty3' to 'PointerShim' in function main()
Error E2340 isarr.cpp 25: Type mismatch in parameter 1 (wanted 'PointerShim', got 'Crafty3') in function main()
Error E2285 isarr.cpp 16: Could not find a match for 'is_array_<Crafty3>::is<U_>(Crafty3 *)' in function main()
Error E2109 isarr.cpp 16: Not an allowed type in function main()
Error E2285 isarr.cpp 16: Could not find a match for 'is_array_<Crafty1[2]>::is<U_>(Crafty1 ( *)[2])' in function main()
Error E2109 isarr.cpp 16: Not an allowed type in function main()
*** 14 errors in Compile ***

 static T_& ret();

template <class T>
 struct Type2Type {
        typedef T OriginalType;
 };

template <class T, class U>
 class TypeIdentity2 {
            static YES   checkit(Type2Type<T>);
            static NO    checkit(...);
        public:
            enum { value = sizeof(checkit(Type2Type<U>())) == sizeof(YES) };
 };

ПК>struct PointerShim
ПК>{
ПК>  PointerShim(const volatile void*);
ПК>};

ПК>template<typename T_> struct is_array_
ПК>{
ПК>  template <typename U_>
ПК>  static char (&is(U_* const*))[1];

  template <typename U_>
  static char (&is(U_* const volatile*))[1];

ПК>  static char (&is(...))[2];
ПК>  static T_* ret();

ПК>  enum { value = sizeof(is(ret())) - 1 };
ПК>};
ПК> ...

typedef void F();
cout << is_array<F>::value << endl;