Re: Forward Declarations of types used in template container classes
Alf P. Steinbach /Usenet wrote:
* Victor Bazarov, on 08.04.2011 23:41:
On 4/8/2011 5:31 PM, Stephen Howe wrote:
Hi
I cant find whether this is valid C++, but I believe it is
// ---------------------------- start header file
#include<vector>
// Forward Declaration
class FooBar;
int SomeFunction1(FooBar); // Valid
declaration, I know this
int SomeFunction2(std::vector<FooBar>& ref); // But is this, on
using std::vector???
// ---------------------------- end header file
Yes FooBar is incomplete but all I am interested in is whether it is a
valid declaration.
All of this is to minimise header file dependency, so FooBar's
definition is not dragged in.
I know that where SomeFunction2 is defined, a full definition of
FooBar is needed.
Since in the context of the declaration of 'SomeFunction2' the full
definition
of 'std::vector<FooBar>' is not required, it is not going to be
instantiated. If
no instantiation happens, FooBar may be incomplete. The declaration of
'SomFunction2' is legal, I suppose.
Not formally.
C++98 ?17.4.3.6/2, about standard library containers:
"In particular, the effects are undefined in the following cases:
[blah blah]
- if an incomplete type (3.9) is used as a template argument when
instantiating a template component"
Why do you think the declaration in OP has to instantiate std::vector<FooBar>?
From 14.7.1-1 (C++ 2003):
Unless a class template specialization has been explicitly instantiated (14.7.2)
or explicitly specialized
(14.7.3), the class template specialization is implicitly instantiated when the
specialization is referenced in a
context that requires a completely-defined object type or when the completeness
of the class type affects the
semantics of the program.
std::vector<FooBar>& does not seem to require a completely-defined object.
-Pavel
That is, standard libary containers are special, in that the element
type must (formally) be complete.
A compiler is free to check, by any means, that the type is complete.
Doing such checking yourself might look like this:
<code>
namespace pedantic {
template< class Elem, int enforcedCompleteness = sizeof( Elem ) >
class Vector
{
// ...
};
}
// Forward Declaration
class FooBar;
int SomeFunction1( FooBar ); // Valid.
int SomeFunction2( pedantic::Vector<FooBar>& ref ); // Invalid.
int main()
{}
</code>
Cheers & hth.,
- Alf