Can a class type be considered both incomplete and abstract?

10.4/2 defines the term "abstract class" as follows: "An abstract
class is a class that can be used only as a base class of some other
class; no objects of an abstract class can be created except as sub-
objects of a class derived from it. A class is abstract if it has at
least one pure virtual function."

This wording says nothing about the location of a class type
definition in a program. There are three possible meanings:

1) A class type defined abstract in some place of a program is
considered abstract only in contexts where it is considered complete.

2) A class type (complete or incomplete), defined abstract at some
place of a program, is considered abstract in each translation unit
where it is defined, but it is considered non-abstract in each
translation unit where it is declared but not defined.

3) A class type (complete or incomplete), defined abstract at some
place of a program, is considered abstract in each translation unit
where it is declared.

What the standard says about the correctness of the following example?
If this example is ill-formed then should the implementation issue a
diagnostic message?

struct Abstract;

Abstract (*arr)[2]; // Ill-formed? No dianostic is required?

struct Abstract
{
     virtual void f() = 0;
};

The standard allows to form a type "array of incomplete type T" (and
we can get a pointer type compounded from a such type), but disallows
to form a type "array of abstract type T". It is unclear, should the
last restriction be applied to the definition of the variable arr
situated before the definition of Abstract. Furthermore, in C++0x
abstractness of a class type can affect the result of the overload
resolution:

#include <iostream>

struct Abstract;

template <class T>
     void f(T *)
         { std::cout << 1 << std::endl; }
template <class T>
     void f(T (*)[1])
         { std::cout << 2 << std::endl; }

int main()
{
     f<Abstract>(0);
}

struct Abstract
{
     virtual void f() = 0;
};

Is this example well-formed according to C++0x and if so then which f
shall be selected? The second f is more specialized, but it can
potentially be excluded from the set of candidate functions due to
abstractness of T.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]