Partial specialization after instantiation, no error?

[dascandy]

The following program produces no warnings, no errors, but doesn't do
what I expect it to. I expect it to produce a warning or error. What
does the standard say about this and/or what should it say? Stroustrup
mentions it's an error (The C++ programming language, p343) but
doesn't say whether the standard says so or whether it's
implementation defined.

Both GCC and MSVC return "4 4 40", showing they instantiated the
template at the first oppurtunity and cached the instantiation.

#include <stdio.h>

template <typename T>
struct A {
T o;
};

int sizeofa = sizeof(A<int *>);

template <typename T>
struct A<T *{
T o[5];
};

int newsizeofa = sizeof(A<int *>);

int main() {
printf("%d, %d %d\n", sizeofa, sizeof(A<int *>),
sizeof(A<double *>));
}

Shouldn't this produce a warning?

[Colander]

On Jun 27, 2:52 pm, "[e-mail]" <[e-mail]:

The following program produces no warnings, no errors, but doesn't do
what I expect it to. I expect it to produce a warning or error. What
does the standard say about this and/or what should it say? Stroustrup
mentions it's an error (The C++ programming language, p343) but
doesn't say whether the standard says so or whether it's
implementation defined.

Both GCC and MSVC return "4 4 40", showing they instantiated the
template at the first oppurtunity and cached the instantiation.

#include <stdio.h>

template <typename T>
struct A {
T o;

};

int sizeofa = sizeof(A<int *>);

template <typename T>
struct A<T *{
T o[5];

};

int newsizeofa = sizeof(A<int *>);

int main() {
printf("%d, %d %d\n", sizeofa, sizeof(A<int *>),
sizeof(A<double *>));

}

Shouldn't this produce a warning?

Nope, it's an error :-)

ComeauTest.c", line 12: error: this partial specialization would have
been used to
instantiate class "A<int *>"
struct A<T *{
^

Look at:
http://www.comeaucomputing.com/tryitout/

Good luck

[dasjotre]

On 27 Jun, 13:52, "[e-mail]" <[e-mail]:

The following program produces no warnings, no errors, but doesn't do
what I expect it to. I expect it to produce a warning or error. What
does the standard say about this and/or what should it say? Stroustrup
mentions it's an error (The C++ programming language, p343) but
doesn't say whether the standard says so or whether it's
implementation defined.

Both GCC and MSVC return "4 4 40", showing they instantiated the
template at the first oppurtunity and cached the instantiation.

#include <stdio.h>

template <typename T>
struct A {
T o;

};

int sizeofa = sizeof(A<int *>);

template <typename T>
struct A<T *{
T o[5];

};

int newsizeofa = sizeof(A<int *>);

int main() {
printf("%d, %d %d\n", sizeofa, sizeof(A<int *>),
sizeof(A<double *>));

}

Shouldn't this produce a warning?

standard says [14.7.3.7]
"When writing a specialization, be careful about
its location; or to make it compile will be such
a trial as to kindle its self-immolation."

with sizeof(A<int*>) you have explicitly instantiated
A for int * . since it comes before the specialization
for pointer types the compiler does its best.
second sizeof(A<int*>) doesn't consider pointer
type specialization since A<int*has already been
instantiated.

since the first instantiation of A<double*is after
pointer type specialization, compiler uses the
specialized version.

regards

DS

[dasjotre]

On 27 Jun, 14:50, dasjotre <[e-mail]:
sorry for duplicate, darn google groups.

[Kai-Uwe Bux]

Colander wrote:

On Jun 27, 2:52 pm, "[e-mail]" <[e-mail]:

>The following program produces no warnings, no errors, but doesn't do
what I expect it to. I expect it to produce a warning or error. What
does the standard say about this and/or what should it say? Stroustrup
mentions it's an error (The C++ programming language, p343) but
doesn't say whether the standard says so or whether it's
implementation defined.

Both GCC and MSVC return "4 4 40", showing they instantiated the
template at the first oppurtunity and cached the instantiation.

#include <stdio.h>

template <typename T>
struct A {
T o;

};

int sizeofa = sizeof(A<int *>);

template <typename T>
struct A<T *{
T o[5];

};

int newsizeofa = sizeof(A<int *>);

int main() {
printf("%d, %d %d\n", sizeofa, sizeof(A<int *>),
sizeof(A<double *>));

}

Shouldn't this produce a warning?

Nope,

Right. It does not need to trigger any diagnostic.

it's an error :-)

Correct, too.

From the standard [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.
^^^^^^^^^^^^^^^^^^^^^^^^^

The good news is that a compiler is allowed to flag this error:

ComeauTest.c", line 12: error: this partial specialization would have
been used to
instantiate class "A<int *>"
struct A<T *{
^

Best

Kai-Uwe Bux

[Default User]

dasjotre wrote:

standard says [14.7.3.7]
"When writing a specialization, be careful about
its location; or to make it compile will be such
a trial as to kindle its self-immolation."

Unusually poetic for a standard.


Brian