Templates and pasring

[vch]

When defining templates, can I cound on the compiler to parse only those
templates that are actually used?

For example, in the following definitions:

<code>

template <class T>
struct Conv
{
// force compile error
abracadabra
};
template <>
struct Conv<int>
{
int foo();
};

template <>
struct Conv<char>
{
// force compile error
abracadabra
};

void f()
{
Conv<int>::foo();
}

</code>

Can I be sure that:

1. If somebody tries to use, say, Conv<char> or Conv<double>, they will
get compile error caused by abracadabra.
2. If they use only Conv<int>, neither generic template nor its
specialization on char will be parsed by the compiler, and no compile
errors will be generated?

[Rolf Magnus]

vch wrote:

When defining templates, can I cound on the compiler to parse only those
templates that are actually used?
I will parse whatever template you give it, unless it's in some #if or
#ifdef.
For example, in the following definitions:

<code>

template <class T>
struct Conv
{
// force compile error
abracadabra
};
template <>
struct Conv<int>
{
int foo();
};

template <>
struct Conv<char>
{
// force compile error
abracadabra
};

void f()
{
Conv<int>::foo();
}

</code>

Can I be sure that:

1. If somebody tries to use, say, Conv<char> or Conv<double>, they will
get compile error caused by abracadabra.
They will always get a compile error.
2. If they use only Conv<int>, neither generic template nor its
specialization on char will be parsed by the compiler, and no compile
errors will be generated?

Wrong.The code must be syntactically correct, since it will be parsed.

[Victor Bazarov]

vch wrote:

When defining templates, can I cound on the compiler to parse only
those templates that are actually used?

For example, in the following definitions:

<code>

template <class T>
struct Conv
{
// force compile error
abracadabra
};
template <>
struct Conv<int>
{
int foo();
};

template <>
struct Conv<char>
{
// force compile error
abracadabra
};

void f()
{
Conv<int>::foo();
}

</code>

Can I be sure that:

1. If somebody tries to use, say, Conv<char> or Conv<double>, they
will get compile error caused by abracadabra.
Kind of. When the code is compiled, the template code is parsed to
determine if there are any glaring syntax errors or any other errors
that are not dependent on how the template is instantiated. However,
some errors (like the existence of a certain member in the 'T' class)
are impossible to diagnose until the template is acutally instantiated.

Those properties of the process are the basis for compile-time asserts
you can read about all over.

Remember, though, that it depends on what in particular is used from
the template. Often,
2. If they use only Conv<int>, neither generic template nor its
specialization on char will be parsed by the compiler, and no compile
errors will be generated?

Again, if the generic template and the 'char' specialisation are such
that do not have syntax errors but instead only depend on the actual
type, then sure, it can be done. Here is an example (you can find
more on the Web or in books or in the news archives):

template<class T> class A; // actually undefined
template<> class A<int> {
public:
void foo();
};

template<> class A<char> {
const int& ri; // impossible to default-initialise
};

int main() {
A<int> ai; // fine
ai.foo(); // fine
A<double> ad; // error - A is not defined for 'double'
A<char> ac; // error - A<char> cannot be constructed
}

Comeau, for example, warns about 'ri' of A<char>, but the only two
errors it reports are still the attempts to define 'ad' and 'ac'.
Same for VC++. I didn't check with others, but that should be seen
across the board.

V

[Greg]

vch wrote:

When defining templates, can I cound on the compiler to parse only those
templates that are actually used?

For example, in the following definitions:

<code>

template <class T>
struct Conv
{
// force compile error
abracadabra
};
template <>
struct Conv<int>
{
int foo();
};

template <>
struct Conv<char>
{
// force compile error
abracadabra
};

void f()
{
Conv<int>::foo();
}

</code>

Can I be sure that:

1. If somebody tries to use, say, Conv<char> or Conv<double>, they will
get compile error caused by abracadabra.
2. If they use only Conv<int>, neither generic template nor its
specialization on char will be parsed by the compiler, and no compile
errors will be generated?

To restate your question using more common terms: Is it possible to
restrict instantiation of a class template to only those types for
which the template has been specialized?

In the example given, Conv<int> and Conv<char> could be instantiated
(because they are specialized), while a Conv instatiated on any other
type would cause an error. (Note that the example seems to want
Conv<char> not to be able to be instantiated; if so, its specialization
Conv<char> should simply be deleted from the source code.)

One of the easiest ways to ensure that the general class template
cannot be instantiated is to declare it with a private constructor:

template <class T>
struct Conv
{
private:
Conv();
};

and then be sure that each specialization of Conv declares a public
constructor:

template <>
struct Conv<int>
{
public:
Conv();
...
};

Greg

[Victor Bazarov]

Greg wrote:

[..]
One of the easiest ways to ensure that the general class template
cannot be instantiated is to declare it with a private constructor:

template <class T>
struct Conv
{
private:
Conv();
};

I always thought that it is actually easier just to omit the
template definition. Just declare it and move on.

V

[Greg]

Victor Bazarov wrote:

Greg wrote:

[..]
One of the easiest ways to ensure that the general class template
cannot be instantiated is to declare it with a private constructor:

template <class T>
struct Conv
{
private:
Conv();
};

I always thought that it is actually easier just to omit the
template definition. Just declare it and move on.

V

Omitting the declaration for the general class template entirely is
certainly more succinct. And as long as none is ever declared, will
prove just as effective as preventing instantiation as a declaration
with a hidden constructor.

Of course there's always a chance some fool, er, I mean, client will
include the header, Conv.h, note the missing declaration and say to
themselves "oh he forgot to declare the body for template class Conv,
no problem, I'll just do it for him...".

Providing the declaration in full, instead of a forward declaration,
has the slight advantage in making clear that the declaration was not
accidentally omitted while at the same time foreclosing anyone else
from providing the declaration of the class template Conv on their own.
And the fact that the client is only trying to be helpful and the rest
of the ensuing conversation - were that ever to happen - can be
blissfully avoided.

Greg

[Victor Bazarov]

Greg wrote:

Victor Bazarov wrote:

Greg wrote:

[..]
One of the easiest ways to ensure that the general class template
cannot be instantiated is to declare it with a private constructor:

template <class T>
struct Conv
{
private:
Conv();
};
I always thought that it is actually easier just to omit the
template definition. Just declare it and move on.

V

Omitting the declaration for the general class template entirely is
certainly more succinct.

I didn't suggest omitting the declaration. Only the definition.
And as long as none is ever declared, will
prove just as effective as preventing instantiation as a declaration
with a hidden constructor.

Of course there's always a chance some fool, er, I mean, client will
include the header, Conv.h, note the missing declaration and say to
themselves "oh he forgot to declare the body for template class Conv,
no problem, I'll just do it for him...".
The body, as you put it, is actually the definition (that part between
and including the curly braces).
Providing the declaration in full, instead of a forward declaration,
has the slight advantage in making clear
That's what the comments are for.
[...]

V