Re: 14/8 says my code is right, compiler says it's wrong
Matthias Hofmann ha scritto:
"Alberto Ganesh Barbati" <AlbertoBarbati@libero.it> schrieb im Newsbeitrag
news:2aZVg.139305$_J1.908965@twister2.libero.it...
The "Error" line implicitly instantiates the traits template, according
to ?14.7.1/1, so the code is ill-formed per ?14.7.1.2/6: "If an implicit
instantiation of a class template specialization is required and the
template is declared but not defined, the program is ill-formed."
So the template must also be *defined*, but where? Does it have to be
defined before any implicit instantiation? In any translation unit where
such an implicit instantiation takes place, or just in one?
The definition must be in scope at the point of the implicit
instantiation. If, as in your case, the point of implicit instantiation
is included in many translation units, then each unit shall include the
definition before that point.
Notice that the error occurs in main.cpp and the presence of the
explicit specialization in item.cpp (a different compilation unit) is
not enough because of ?14.7.3/6: "If a template, a member template or
the member of a class template is explicitly specialized then that
specialization shall be declared before the first use of that
specialization that would cause an implicit instantiation to take place,
in every translation unit in which such a use occurs; no diagnostic is
required."
So the specialization must be declared before any implicit instantiation,
but what about the definition?
Be careful, because in your particular case there are two entities
involved: the member function and its class template. The entity that is
being referenced is the member function, so, in theory, you would only
need the declaration of *that*. Unfortunately, in order to declare the
member function, you need to provide the whole class template definition.
Notice that, in this particular case, you can't just declare the
specialization item_traits<Item<int>>, because in order to use foo() you
also need the declaration of that! So you must provide the entire
definition of item_traits<Item<int>> in item.h (you don't need to
provide the definition of foo(), however).
Where does the standard say that I need to provide the entire definition
before the implicit instantiation?
?14.7.1.2/6... did you read my post?
I would loathe to provide the definition of the template specialization in a
header file, because my intent is to separate interface and implementation.
In my example, "item.h" would be included in many translation units, so any
change to the template specialization would require recompilation of each of
these translation units.
You don't need to define all member function, just the class definition
is enough. For example:
---- item.h
template <class T> struct item_traits;
template <class T> class Item; // forward declaration
// definition of item_traits< Item<int> >
template <> struct item_traits< Item<int> >
{
static int foo(); // declaration of foo()
};
template <class T> class Item
{
public:
typedef item_traits< Item<T> > traits_type;
int foo() { return traits_type::foo(); }
};
---- item.cpp
#include "item.h"
int item_traits< Item<int> >::foo() { return 42; }
----
Ganesh
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]