Re: template with const as parameter
On Jun 9, 12:14 pm, Paul Bibbings <paul.bibbi...@gmail.com> wrote:
MiB <michael.boehni...@gmail.com> writes:
On Jun 9, 7:42 am, charlie <charlie.xia....@gmail.com> wrote:
const float t = 0;
template < class T, const T& >
class A {
public:
A();};
typedef A<float, t> AA;
why above doesn't work and gives following errors?
The second template parameter is the culprit.
1. Only types and values of integral types are allowed as template
parameters - float is not an integral type,
so you cannot use it for a value template parameter.
Your wording is a little loose here. The three `kinds' or template
parameter are type, non-type and template template parameters. You are
referring to the OP's example in relation to non-type template
parameters (which you call a `value template parameter'). Your analysis
that a float cannot be used here is, however, broadly correct.
It's not correct at all, since the original poster doesn't use
a float; he uses a reference to a float.
2. Also, you cannot use references as specifiers of value template
arguments:
This is not so, as stated. The key point here is that the non-type
template argument must be a run-time constant. The OP uses const T&
and, for this usage, the reference is perfectly acceptable (see below).
Note, however, that it the template argument itself must have external
linkage to satisfy the requirements of matching this parameter. It
must, also, be an lvalue.
The external linkage is, in fact, the only relevant issue here.
And of course, since nothing that isn't an lvalue has linkage,
the initializing expression must be an lvalue, constant
expression.
the reference is in a way a hidden
pointer and receives a value at runtime. Template instantiation is
performed at compile time. Thus, while the
value of t is known by the compiler, its address in memory is not
yet determined and the template mechanism
must fail.
The standard requires it to work, and it does work with the
compilers I've seen.
3. You did not give a name to the second parameter, only its type. How
do you plan to reference the value from
the instantiation in your class definition?
These need not always be an issue (see below).
The error messages you get are admittedly not very enlightening.
Summing it up:
template <class T, float t> class A {}; // illegal for reason #1
Agreed.
But irrelevant with regards to the original code.
template <class T, int& i> class B {}; // illegal for reason #2
Illegal as given,
Perfectly legal.
but not *entirely* for the reason stated and, further, not
a good example with which to comment upon the users code,
which uses *const* T&. The effect of adding a reference here
is *not* that references are disallowed as such, but that
a *non-const* reference does not result in a compile-time
constant. Consider:
A reference is always constant. The only issue here is that the
*argument* must be a non-const lvalue with external linkage.
Declare
int i;
and you can use i as the second argument of the template
(provided that the definition is at namespace scope, of course).
template<class T, const T& t>
class B { };
extern const int i = 42;
B<int, i> b; // OK
template <class T, int> class C {}; // illegal for reason #3
Not *illegal* in any sense. Indeed, it is not even necessarily an
omission where the type may be used as a selector, for instance.
It's actually a fairly common technique.
--
James Kanze