Straight from Wikipedia:
In general, a translation unit shall contain no more than one
definition of any class type. In this
example, two definitions of the class
type C occur in the same translation
unit. This typically occurs if a
header file is included twice by the
same source file without appropriate
header guards.
class C {}; // first definition of C
class C {}; // error, second definition of C
n the following, forming a pointer to
S or defining a function taking a
reference to S are examples of legal
constructs, because they do not
require the type of S to be complete.
Therefore, a definition is not
required.
Defining an object of type S, a
function taking an argument of type S,
or using S in a sizeof expression are
examples of contexts where S must be
complete, and therefore require a
definition.
struct S; // declaration of S
S * p; // ok, no definition required
void f(S&); // ok, no definition required
void f(S); // ok, no definition required
S f(); // ok, no definition required
S s; // error, definition required
sizeof(S); // error, definition required
More than one definition
In certain cases, there can be more
than one definition of a type or a
template. A program consisting of
multiple header files and source files
will typically have more than one
definition of a type, but not more
than one definition per translation
unit.
If a program contains more than one
definition of a type, then each
definition must be equivalent.
Definitions of static const data members
In pre-standard C++, all static data
members required a definition outside
of their class. However, during the
C++ standardization process it was
decided to lift this requirement for
static const integral members. The
intent was to allow uses such as:
struct C
{
static const int N = 10;
};
char data[C::N]; // N "used" without out-of-class definition
without a namespace scope definition for N.
Nevertheless, the wording of the 1998 C++ standard still required a
definition if the member was used in
the program. This included the
member appearing anywhere except as
the operand to sizeof or typeid,
effectively making the above
ill-formed.
This was identified as a defect, and the wording was adjusted to allow
such a member to appear anywhere a
constant expression is required,
without requiring an out-of-class
definition. This includes array
bounds, case expressions, static
member initializers, and nontype
template arguments.
struct C
{
static const int N = 10;
static const int U = N; // Legal per C++03
};
char data[C::N]; // Legal per C++03
template<int> struct D;
template<> struct D<C::N> {}; // Legal per C++03
However, using a static const integral
member anywhere except where an
integral constant-expression is
required requires a definition
struct C
{
static const int N = 10;
};
int main()
{
int i = C::N; // ill-formed, definition of C::N required
}
This requirement will be relaxed in
the upcoming C++ standard,
colloquially referred to as C++0x.
