C++ Standard Core Language
Closed Issues,
Revision
55

This document contains the C++ core language issues for which the
Committee (J16 + WG21) has decided that no action is required,
that is, issues with status
"NAD" ("Not A Defect"),
"dup" (duplicate), and
"extension."

This document is part of a group of related documents that
together describe the issues that have been raised regarding the
C++ Standard. The other documents in the group are:

Active Issues List, which contains
explanatory material for the entire document group and a list of
the issues that have not yet been acted upon by the Committee.

Defect Reports List, which contains
the issues that have been categorized by the Committee as Defect
Reports, along with their proposed resolutions.

Table of Contents, which contains a
summary listing of all issues in numerical order.

Index by Section, which contains a
summary listing of all issues arranged in the order of the
sections of the Standard with which they deal most directly.

Index by Status, which contains a
summary listing of all issues grouped by status.

For more information, including a description of the meaning of
the issue status codes and instructions on reporting new issues,
please see the Active Issues List.

Issues with "NAD" Status

449.
Consistency in use of hyphen with names of "non" entities

The standard is inconsistent in its use of a hyphen on the
following:
nontype vs. non-type,
non-dependent vs. nondependent,
non-deduced vs. nondeduced, and
non-template vs. nontemplate.
We should pick a preferred form.

Notes from the March 2004 meeting:

If this isn't a purely editorial issue, nothing is. We're referring this
to the editor. We prefer the hyphenated forms.

~Bar() calls ~Foo(), which is ill-formed due to access
violation, right? (Bar's constructor has the same problem since it
needs to call Foo's constructor.) There seems to be some disagreement
among compilers. Sun, IBM and g++ reject the testcase, EDG and HP
accept it. Perhaps this case should be clarified by a note in the
draft.

In short, it looks like a class with a virtual private base can't be
derived from.

Rationale: This is what was intended.

17.
Footnote 99 should discuss the naming class when describing members that can be accessed from friends

As specified previously in clause 11
[class.access]
, private members
of a base class remain inaccessible even to derived classes unless friend
declarations within the base class declaration are used to grant access
explicitly.

This footnote does not fit with the algorithm provided in
11.2
[class.access.base]
paragraph 4 because
it does not take into account the naming class concept introduced in this
paragraph.

(See also paper J16/99-0002 = WG21 N1179.)

Rationale (10/99): The footnote should be read as referring
to immediately-derived classes, and is accurate in that context.

This question affects both the existing wording of
11.2
[class.access.base] paragraph 4 (“m as a
member of N is public ... m as a member of N
is private ... m as a member of N is
protected”) and the proposed wording for issue 385 (“when a nonstatic data member or
nonstatic member function is a protected member of its naming
class”).

One possible definition of “is public” would be
something like, “if any visible declaration of the entity
has public access.” One could also plausibly define the
access of m in N to be the minimum of all the
visible declarations, or even an error if the visible
declarations are inconsistent.

11.2
[class.access.base] paragraph 1 describes the access of
inherited members, so a clarifying statement resolving this issue
might plausibly be inserted at the end of that paragraph.

Proposed resolution (October, 2004):

Add the following text as a new paragraph after 11.2
[class.access.base] paragraph 1:

If a given base class can be reached along more than one path
through a derived class's sub-object lattice (10.1
[class.mi]), a member of that base class could have different
accessibility in the derived class along different paths. In
such cases, the most permissive access
prevails. [Example:

I discussed this with Bjarne in email, and he thinks it was an
editorial error and this was not the committee's intention. The
paragraph seems to have been added in the pre-Kona (24 Sept 1996)
mailing, and I could not find anything in the previous meeting's
(Stockholm) mailings which led me to believe this was intentional. The
only compiler vendor which I think currently implements it is the
latest release (2.43) of the EDG front end.

Proposed resolution (10/00):

Remove the first sentence of 11.4
[class.friend], paragraph 7.

Rationale (04/01):

After the 10/00 vote to accept this issue as a DR with the
proposed resolution, it was noted that the first two sentences
of 11
[class.access] paragraph 3 cause the proposed change
to have no effect:

Access control is applied uniformly to all names, whether the names
are referred to from declarations or expressions. [Note: access
control applies to names nominated by friend declarations
(11.4
[class.friend]) and using-declarations
(7.3.3
[namespace.udecl]). ]

In addition to the obvious editing to the text of the note,
an exception to the blanket statement in the first sentence
would also be required. However, discussion during the 04/01
meeting failed to produce consensus on exactly which names
in the friend declaration should be exempted from the
requirements of access control.

One possibility would be that only the name nominated as
friend should be exempt. However, that approach
would make it impossible to name a function as a friend if it
used private types in its parameters or return type. Another
suggestion was to ignore access for every name used in a
friend declaration. That approach raised a question
about access within the body of a friend function
defined inline in the class body — the body is part of
the declaration of a function, but references within the body
of a friend function should still be subject to the
usual access controls.

Other possibilities were raised, such as allowing the
declaration of a friend member function if the
declaration were permissible in its containing class, or
taking the union of the access within the befriending class
and the befriended entity. However, these suggestions would
have been complex and difficult to specify correctly.

Ultimately it was decided that the original perceived
defect was not sufficiently serious as to warrant the degree
of complexity required to resolve it satisfactorily and the
issue was consequently declared not to be a defect. It was
observed that most of the problems involved with the current
state of affairs result from inability to declare a
particular member function as a friend; in such cases,
an easy workaround is simply to befriend the entire class
rather than the specific member function.

445.
Wording issue on friend declarations

A name nominated by a friend declaration shall be accessible
in the scope of the class containing the friend declaration.

The obvious intention of this is to allow a friend declaration to
specify a function (or nested class, enum, etc.) that is declared
"private" or "protected" in its enclosing class. However, literal
interpretation seems to allow a broader access to the befriended
function by the whole class that is declaring the friendship.

If the rule were interpreted literally as it is currently written, this
would compile (when it, of course, shouldn't be allowed at all):

I believe that the special invisibility rule about friends is too
complicated and makes life too complicated, especially considering
that friends in templates are not templates, nor can they be
conveniently rewritten with a “first declare at the namespace
scope” rule. I can understand the rules when they make
programming easier or prevent some obvious “silly”
mistakes; but that does not seem to be the case here.

John Spicer: See two papers that discuss this issue: N0878
by Bill Gibbons, which ultimately gave rise to our current rules, and
N0913 by me as an alternative to N0878.

Rationale (April, 2005):

The Standard is clear and consistent; this rule is the result of an
explicit decision by the Committee.

117.
Timing of destruction of temporaries

the temporary that holds the result of the expression shall persist
until the object's initialization is complete... the temporary
is destroyed after it has been copied, before or when the
initialization completes.

How can it be destroyed "before the initialization completes" if
it is required to "persist until the object's initialization is
complete?"

Rationale (04/00):

It was suggested that "before the initialization completes" refers
to the case in which some part of the initialization terminates by
throwing an exception. In that light, the apparent contradiction does
not apply.

3.8
[basic.life] paragraph 6 indicates that the
references here are valid. It's permitted to take the address
of a class object before it is fully initialized, and it's
permitted to pass it as an argument to a reference parameter
as long as the reference can bind directly.
Except for the failure to cast the pointers
to void * for the %p in the printfs,
these examples are standard-conforming.

307.
Initialization of a virtual base class subobject

The second paragraph of section 12.7
[class.cdtor] contains the
following text:

To explicitly or implicitly convert a pointer (an
lvalue) referring to an object of class X to a pointer (reference) to
a direct or indirect base class B of X, the construction of X and the
construction of all of its direct or indirect bases that directly or
indirectly derive from B shall have started and the destruction of
these classes shall not have completed, otherwise the conversion
results in undefined behavior.

The problem with the above snippet is that when the value 'ac2' is
being created and its construction gets started, c's copy constructor
has first to initialize the virtual base class subobject 'a'. Which
requires that the lvalue expression 'rhsc' be converted to the type of
the parameter of a's copy constructor,
which is 'const a&'. According
to the wording quoted above, this can be done without undefined
behaviour if and only if b's construction has already started, which
is not possible since 'a', being a virtual base class, has to be
initialized first by a constructor of the most derived object
(12.6.2
[class.base.init]).

The issue could in some cases be alleviated when 'c' has a
user-defined copy constuctor. The constructor could default-initialize
its 'a' subobject and then initialize a's members
as needed taking
advantage of the latitude given in paragraph 2 of
12.6.2
[class.base.init].

But if 'c' ends up having the implicitly-defined copy constuctor,
there's no way to evade undefined behaviour.

The
implicitly-defined copy constructor for class X performs a memberwise
copy of its subobjects. The order of copying is the same as the order
of initialization of bases and members in a user-defined constructor
(see 12.6.2
[class.base.init]).
Each subobject is copied in the manner appropriate to
its type:

if the subobject is of class type, the copy constructor for the
class is used;

Which effectively means that the implicitly-defined copy constructor
for 'c' will have to initialize its 'a'
base class subobject first and
that must be done with a's copy constructor, which will always require
a conversion of an lvalue expression of type 'const c' to an lvalue of
type 'const a&'. The situation would be the same if all the three
classes shown had implicitly-defined copy constructors.

Suggested resolution:

Prepend to paragraph 2 of 12.7
[class.cdtor] the following:

Unless the conversion happens in a mem-initializer whose
mem-initializer-id designates a virtual base class of X, to explicitly
or implicitly convert ...

Notes from the 10/01 meeting:

There is no problem in this example. ac1 is fully initialized
before it is used in the initialization of ac2.

Rationale:
There is no need for additional wording. This example leads to
a program which either fails to compile (due to resource limits on recursive
inlining) or fails to run (due to unterminated recursion). In either case
the implementation may generate an error when the program is compiled.

356.
Wording of behavior of generated copy constructor for scalar members

The Core Working Group believes this should not be changed. The
standard already mentions built-in operators and the
assignment operator does clearly define what must be done for
scalar types. There is currently no concept of
built-in initialization.

If you look at 12.8
[class.copy] paragraph 10 it
explicitly states that
in such a case the "using B::operator=" will not be considered.

Steve Adamczyk:
The fact that the operator= you declared is (D&) and not (const D&)
is fooling you. As the standard says, the operator= introduced
by the using-declaration does not suppress the generation of
the implicit operator=. However, the generated operator= has the
(const D&) signature, so it does not hide B::operator=;
it overloads it.

Kerch Holt:
I'm not sure this is correct. Going by 12.8 P10 first paragraph
we think that the other form "operator=(D&)" is generated because
the two conditions mentioned were not met in this case.
1) there is no direct base with a "const [volatile] B&" or "B" operator
2) And no member has a operator= either.
This implies the implicit operator is "operator=(D&)".
So, if that is the case the "hiding" should happen.

Also, in the last paragraph it seems to state that operators
brought in from "using", no matter what the parameter is, are
always hidden.

Steve Adamczyk:
Not really. I think this section is pretty clear about the fact that
the implicit copy assignment operator is generated. The question is whether it
hides or overloads the one imported by the using-declaration.

Notes from the March 2004 meeting:

(a) Class B does get an implicitly-generated
operator=(const B&); (b) the using-declaration brings in
two operator= functions from B, the explicitly-declared
one and the implicitly-generated one; (c) those two functions overload
with the implicitly-generated operator=(const D&) in
the derived class, rather than being hidden by the derived-class
function, because it does not match either of their signatures;
(d) overload resolution picks the explicitly-declared
function from the base class because it's the best match in this
case. We think the standard wording says this clearly enough.

According to
3.4.1
[basic.lookup.unqual]
paragraph 6, I would expect that the "+" call inside
std::accumulate would find the global operator+.
Is this true, or am I
missing a rule? Clearly, the operator+ would be found by Koenig lookup
if it were in namespace N.

Daveed Vandevoorde:
But doesn't unqualified lookup of
the operator+ in the definition
of std::accumulate proceed in the namespace where the implicit
specialization is generated; i.e., in namespace std?

In that case, you may find a non-empty overload set for operator+
in namespace std and the surrounding (global) namespace is no longer
considered?

Nathan Myers:
Indeed, <string> defines operator+,
as do <complex>, <valarray>,
and <iterator>. Any of these might hide the global operator.

This technique (copying from a map to another container or stream)
should work. If it really cannot be made to work, that would seem broken
to me. The reason is does not work is that copy and pair are in
namespace std and the name lookup rules do not permit the global
operator<< to be found because the other operator<<'s
in namespace std
hide the global operator. (Aside: FWIW, I think most programmers don't
realize that a typedef like CPair is actually in namespace std, and not
the global namespace.)

Bill Gibbons: It looks like part of this problem is that the library
is referring to names which it requires the client to declare in the global namespace
(the operator names) while also declaring those names in namespace std.
This would be considered very poor design for plain function names; but the
operator names are special.

There is a related case in the lookup of operator conversion functions. The
declaration of a conversion function in a derived class does not hide any
conversion functions in a base class unless they convert to the same type.
Should the same thing be done for the lookup of operator function names,
e.g. should an operator name in the global namespace be visible in namespace
std unless there is a matching declaration in std?

Because the operator function names are fixed, it it much more likely that
a declaration in an inner namespace will accidentally hide a declaration
in an outer namespace, and the two declarations are much less likely to
interfere with each other if they are both visible.

The lookup rules for operator names (when used implicitly) are already
quite different from those for ordinary function names. It might be worthwhile
to add one more special case.

Mike Ball
: The original SGI proposal said that non-transitive points of
instantiation were also considered. Why, when, and by whom was it added?

Rationale (10/99): This appears to be mainly a program
design issue. Furthermore, any attempt to address it in the core
language would be beyond the scope of what can be done in a
Technical Corrigendum.

423.
Can a conversion be done on the left operand of a compound assignment?

Is it possible that by "assignment operators"
(13.3.1.2
[over.match.oper] paragraph 4) only the built-in
candidates for operator= (i.e. excluding +=, *=, etc.) were meant? On one hand
the plural ("operators") seems to imply that all the assignment operators are
considered. OTOH, there has already been a core DR (221) about a missing
distinction between "assignment operator" and "compound assignment operators".
Is there a similar defect here?

Steve Adamczyk:
The standard is ambiguous. However,
I think the ARM was fairly clear about "assignment operators" meaning only
"=", and I find that Cfront 3.0.1 accepts the test case (with typename
changed to class). I don't know whether that's good or bad, but it's
at least a precedent. Given the change of
Core Issue 221, if we do nothing
further conversions are valid on += and therefore this case is valid.

Note that "t2++;" is unquestionably valid, so one could
also argue for the status quo (post-221) on the basis of consistency.

Notes from the October 2003 meeting:

We believe the example is well-formed, and no change other than
that in issue 221 is needed.

This is pretty much the definition of "ambiguous," right? You want
to convert a B to an A, and there are two equally
good ways of doing that: a constructor of A that takes a
B, and a conversion function of B that returns an
A.

What we discover when we trace this through the standard,
unfortunately, is that the constructor is favored over the conversion
function. The definition of direct-initialization (the parenthesized
form) of a class considers only constructors of that class. In this
case, the constructors are the A(B) constructor and the
(implicitly-generated) A(const A&) copy constructor.
Here's how they are ranked on the argument match:

A(B)

exact match (need a B, have a B)

A(const A&)

user-defined conversion (B::operator A used to
convert B to A)

In other words, the conversion function does get considered, but
it's operating with, in effect, a handicap of one user defined
conversion. To put that a different way, this problem is a problem of
weighting, not a problem that certain conversion paths are not
considered.

I believe the reason that the
standard's approach doesn't yield the "intuitive" result is
that programmers expect copy constructor elision
to be done whenever reasonable, so the intuitive cost of using
the conversion function in the example above is simply the cost
of the conversion function, not the cost of the conversion function
plus the cost of the copy constructor (which is what the standard
counts).

Suggested resolution:

In a direct-initialization overload
resolution case, if the candidate function being called is a copy
constructor and its argument (after any implicit conversions) is a
temporary that is the return value of a conversion function, and the
temporary can be optimized away, the cost of the argument match for
the copy constructor should be considered to be the cost of the
argument match on the conversion function argument.

Notes from 10/01 meeting:

It turns out that there is existing practice both ways on this
issue, so it's not clear that it is "broken". There is some reason to
feel that something that looks like a "constructor call" should call a
constructor if possible, rather than a conversion function.
The CWG decided to leave it alone.

61.
Address of static member function "&p->f"

Can p->f, where f refers to a set of overloaded functions
all of which are static member functions, be used as an expression in an
address-of-overloaded-function context? A strict reading of this
section suggests "no", because "p->f" is not the name of an overloaded
function (it's an expression). I'm happy with that, but the core
group should decide and should add an example to document the decision,
whichever way it goes.

Rationale (10/99): The "strict reading" correctly reflects
the intent of the Committee, for the reason given, and no clarification
is required.

This would appear to make the program ill-formed, since the
type in the cast is different from that of either interpretation
of the address-of-member expression (its class is A,
while the class of the address-of-member expression is B)

However, 13.4
[over.over] paragraph 3 says,

Nonstatic member functions match targets of type
"pointer-to-member-function;" the function type of the pointer
to member is used to select the member function from the set
of overloaded member functions.

The class of which a function is a member is not part of the
"function type" (8.3.5
[dcl.fct] paragraph 4).
Paragraph 4 is thus either a misuse of the phrase "function type," a
contradiction of paragraph 1, or an explanation of what "matching
the target type" means in the context of a pointer-to-member
target. By the latter interpretation, the example is well-formed
and B::foo() is selected.

Bill Gibbons: I think this is an accident due to vague
wording. I think the intent was

The function selected is the one which will make the effect of
the cast be that of the identity conversion.

Mike Miller: The "identity conversion" reading seems
to me to be overly restrictive. It would lead to the following:

I would find the need for an explicit cast here surprising, since
the downcast is a standard conversion and since the declaration of
p1 certainly has enough information to disambiguate the
overload set. (See also issue 203.)

Bill Gibbons: There is an interesting situation with
using-declarations. If a base class member function is present
in the overload set in a derived class due to a
using-declaration, it is treated as if it were a derived class
member function for purposes of overload resolution in a call
(13.3.1
[over.match.funcs] paragraph 4):

For non-conversion functions introduced by a using-declaration
into a derived class, the function is considered to be a member of the
derived class for the purpose of defining the type of the implicit
object parameter

There is no corresponding rule for casts. Such a rule would be
practical, but if the base class member function were selected it
would not have the same class as that specified in the cast. Since
base-to-derived pointer to member conversions are implicit
conversions, it would seem reasonable to perform this conversion
implicitly in this case, so that the result of the cast has the right
type. The usual ambiguity and access restrictions on the
base-to-derived conversion would not apply since they do not apply to
calling through the using-declaration either.

On the other hand, if there is no special case for this, we end up with
the bizarre case:

struct A {
void foo();
};
struct B : A {
using A::foo;
void foo(int);
}
int main() {
// Works because "B::foo" contains A::foo() in its overload set.
(void (A::*)())&B::foo;
// Does not work because "B::foo(int)" does not match the cast.
(void (A::*)(int))&B::foo;
}

I think the standard should be clarified by either:

Adding a note to 13.4
[over.over] saying that
using-declarations do not participate
in this kind of overload resolution; or

Modifying 13.4
[over.over] saying that
using-declarations are treated as members of the derived class
for matching purposes, and if selected, the resulting pointer to
member is implicitly converted to the derived type with no access or
ambiguity errors. (The using-declaration itself has already
addressed both of these areas.)

Rationale (10/00): The cited example is well-formed.
The function type, ignoring the class specification, is used to
select the matching function from the overload set as specified
in 13.4
[over.over] paragraph 3. If the target
type is supplied by an explicit cast, as here, the conversion is
then performed on the selected pointer-to-member value, with the
usual restrictions on what can and cannot be done with the
converted value (5.2.9
[expr.static.cast] paragraph 9,
5.2.10
[expr.reinterpret.cast] paragraph 9).

552.
Use of typename in the type in a non-type parameter-declaration

The discussion in of the use of typename with a
qualified-id in a template parameter-declaration in
14.2
[temp.names] paragraph 2 is confusing:

typename followed by an unqualified-id names a
template type parameter. typename followed by
a qualified-id denotes the type in a non-type
parameter-declaration.

This rule would be clearer if the unqualified-id case were
described in terms of resolving the ambiguity of declaring a
template parameter name versus referring to a type-name
from the enclosing scope, and if the qualified-id case
referred to the use of the typename keyword with
dependent types in 14.6
[temp.res]. An example would
also be helpful.

If not, I think the creation of a specialization that would have been
an override had it been declared in the class should be an error.

Daveed Vandevoorde:
There is real code out there that is written with this rule
in mind. Changing the standard on them would not be good
form, IMO.

Mike Ball:
Also, if you allow template functions to be specialized outside
of the class you introduce yet another non-obvious ordering constraint.

Please don't make such a change after the fact.

John Spicer: This is the result of an explicit committee
decision. The reason for this rule is that it is too easy to
unwittingly override a function from a base class, which was probably
not what was intended when the template was written. Overriding
should be a conscious decision by the class writer, not something done
accidentally by a template.

Rationale (10/99): The Standard correctly reflects the
intent of the Committee.

Notes from October 2002 meeting:

This was reopened because of a discussion while reviewing possible
extensions.

Notes from April 2003 meeting:

This was discussed again, and the consensus was that we did
not want to make a change, and in particular we did not want to
make it an error and risk breaking existing code.

47.
Template friend issues

Paragraph 1 says that a friend of a class template can be a template.
Paragraph 2 says: A friend template may be declared within a non-template
class. A friend function template may be defined within a non-template
class.

I'm not sure what this wording implies about friend template definitions
within template classes. The rules for class templates and normal classes
should be the same: a function template can be declared or defined, but
a class template can only be declared in a friend declaration.

Issue 2

Paragraph 4 says: When a function is defined in a friend function declaration
in a class template, the function is defined when the class template is
first instantiated. I take it that this was intended to mean that a function
that is defined in a class template is not defined until the first instantiation.
I think this should say that a function that is defined in a class template
is defined each time the class is instantiated. This means that a function
that is defined in a class template must depend on all of the template
parameters of the class template, otherwise multiple definition errors
could occur during instantiations. If we don't have a rule like this, compilers
would have to compare the definitions of functions to see whether they
are the same or not. For example:

then the two definitions of "f" are identical so there is no ODR
violation, but it is still a redefinition. I think this is just an editorial
clarification.

Rationale (04/99): The first sub-issue reflects wording that was
changed to address the concern before the IS was issued. A close and
careful reading of the Standard already leads to the conclusion that the
example in the second sub-issue is ill-formed, so no change is needed.

229.
Partial specialization of function templates

How can a 3rd party library implementor (lib1) write a version of
a standard algorithm which is specialized to work with his own class
template?

How can another library implementor (lib2) write a generic
algorithm which will take advantage of the specialized algorithm in
lib1?

For example, a programmer might want to provide a version of
std::swap that would be used for any specialization of a
particular class template. It is possible to do that for specific
types, but not for all specializations of a template.

The problem is due to the fact that programmers are forbidden to
add overloads to namespace std, although specializations are
permitted. One suggested solution would be to allow partial
specialization of function templates, analogous to partial
specialization of class templates.

Library issue 225 contains a detailed proposal for adding partial
specialization of function templates (not reproduced here in the
interest of space and avoiding multiple-copy problems). This Core
issue is being opened to provide for discussion of the proposal within
the core language working group.

Notes from 10/00 meeting:

A major concern over the idea of partial specialization of
function templates is that function templates can be overloaded,
unlike class templates. Simply naming the function template in
the specialization, as is done for class specialization, is not
adequate to identify the template being specialized.

In view of this problem, the library working group is exploring
the other alternative, permitting overloads to be added to functions
in namespace std, as long as certain restrictions (to be
determined) are satisfied.

presumably because the DR from issue 176
says that we decide whether or not
B is to be treated as a template depending on whether a
template-argument-list is supplied. I think this is a drafting oversight,
and that B should also be treated as a template when passed as a template
template parameter. The discussion in the issue list only talks about
making the name usable both as a class and as a template.

John Spicer:
This case was explicitly discussed and it was agreed that to use the injected
name as a template template parameter you need to use the non-injected
name.

A (possibly unstated) rule that I've understood about template
arguments is that
the form of the argument (type/nontype/template) is based only on the
argument and not on the kind of template parameter. An example is that
"int()" is always "function taking no arguments returning int"
and never a convoluted way of saying zero.

In a similar way, we now decide whether or not something is a template based
only on the form of the argument.

I think this rule is important for two kinds of cases. The first case
involves explicit arguments of function templates:

544.
Base class lookup in explicit specialization

There is some question as to whether 14.6.2
[temp.dep]
paragraph 3 applies to the definition of an explicitly-specialized
member of a class template:

In the definition of a class template or a member of a class template,
if a base class of the class template depends on
a template-parameter, the base class scope is not examined
during unqualified name lookup either at the point of definition of
the class template or member or during an instantiation of the class
template or member.

Does foo in the definition of B<int>::bar()
refer to ::foo() or to A<int>::foo()?

Rationale (April, 2006):

An explicitly-specialized member of a class template is not, in
fact, a member of a class template but a member of a particular
specialization of that template. The special treatment of lookup
vis-a-vis dependent base classes in 14.6.2
[temp.dep]
thus does not apply, and base class members are found by unqualified
name lookup.

According to the standard, it is, because 14.6.2.2
[temp.dep.expr]
says that an expression is dependent if any of its sub-expressions is
dependent, but there is a question about whether the language should
say something different. The type and value of the expression are not really
dependent, and similar cases (like casting T::x
to int) are not dependent.

Mark Mitchell: If the first operand is dependent, how
do we know it does not have an overloaded comma operator?

Rationale (October, 2004):

CWG agreed that such comma expressions are and ought to be
dependent, for the reason expressed in Mark Mitchell's
comment.

34.
Argument dependent lookup and points of instantiation

Does Koenig lookup create a point of instantiation for class types?
I.e., if I say:

TT<int> *p;
f(p);

The namespaces and classes associated with p are those associated with
the type pointed to, i.e., TT<int>. However, to determine those
I need to know TT<int> bases and its friends, which requires
instantiation.

Or should this be special cased for templates?

Rationale:
The standard already specifies that this creates a point of instantiation.

489.
Must member function templates be instantiated during overload resolution?

A related question to that raised in issue 488 is whether member function templates must be
instantiated if the compiler can determine that they will not be
needed by the function selected by overload resolution. That is
explicitly specified for class templates in 14.7.1
[temp.inst] paragraph 5:

If the overload resolution process can determine the correct function
to call without instantiating a class template definition, it is
unspecified whether that instantiation actually takes place.

Should the same be true for member function templates? In the
example from issue 488,

a compiler could conceivably determine that f(int)
would be selected by overload resolution (because it involves
only an integral promotion, while the alternative requires a
user-defined conversion) without instantiating the declaration of
the S constructor. Should the compiler have that
freedom?

Rationale (April, 2005):

In order for this question to come up, there would need to be a
“gap” between the the normal rules and the rules for
template argument deduction failure. The resolution for
issue 488 will close the only such
gap of which the CWG is aware. The issue can be reopened if other
such cases turn up.

Since multiple "template<>" clauses are permitted in an explicit
specialization, it might follow that multiple "template" keywords
should also be permitted in an explicit instantiation. Are multiple "template"
keywords not allowed in an explicit instantiation? The grammar permits
it, but the grammar permits lots of stuff far weirder than that.
My opinion is that, in the absence of explicit wording permitting that
kind of usage (as is present for explicit specializations) that such usage
is not permitted for explicit instantiations.

Rationale (04/99): The Standard does not describe the meaining
of multiple template keywords in this context, so the example
should be considered as resulting in undefined behavior according to
1.3
[intro.defs] “undefined behavior.”

[N1065 issue 1.19] An explicit specialization declaration may not be
visible during instantiation under the template compilation model rules,
even though its existence must be known to perform the instantiation correctly.
For example:

For the member template case, the array size "sizeof(B)" cannot
be evaluated until the template is instantiated because B might
be specialized. Similarly, the array size "i" cannot be evaluated
until the template is instantiated.

Rationale (10/99): The Standard is already sufficiently clear
on this question.

The usual access checking rules do not apply to names used to specify
explicit instantiations. [Note: In particular, the template arguments
and names used in the function declarator (including parameter types,
return types and exception specifications) may be private types or
objects which would normally not be accessible and the template may be
a member template or member function which would not normally be
accessible. ]

I was surprised that similar wording does not exist (that I could find) for
explicit specializations. I believe that the two cases should be handled
equivalently in the example below (i.e., that the specialization should be
permitted).

if the name of a template-argument is accessible
at the point where it is used as a template-argument,
there is no further access restriction in the
resulting instantiation where the corresponding
template-parameter name is used.

(Is this specified anywhere in the normative text? Should
it be?)

In the absence of text to the contrary, this blanket
permission apparently applies to explicitly-specialized
templates as well as to implicitly-generated ones (is that
right?). If so, I don't see any reason that an explicit
instantiation should be treated differently from an explicit
specialization, even though the latter involves new program
text and the former is just a placement instruction to the
implementation.

Proposed Resolution (4/02):

In 14.7.2
[temp.explicit] delete paragraph 8:

The usual access checking rules do not apply to names used to specify explicit
instantiations. [Note: In particular, the template arguments and names used in
the function declarator (including parameter types, return types and exception
specifications) may be private types or objects which would normally not be
accessible and the template may be a member template or member function which
would not normally be accessible. ]

In 14.7
[temp.spec] add the paragraph deleted above as
paragraph 7 with the changes highlighted below:

The usual access checking rules do not apply to names used to specify explicit
instantiations or explicit specializations. [Note: In
particular, tThe template arguments and names used in the
function declarator (including parameter types, return types and exception
specifications) may be private types or objects which would normally not be
accessible and the template may be a member template or member function
which would not normally be accessible. ]

Rationale (October 2002):

We reconsidered this and decided that the difference between the
two cases (explicit specialization and explicit instantiation) is
appropriate. The access rules are sometimes bent when necessary to
allow naming something, as in an explicit instantiation, but
explicit specialization requires not only naming the entity but
also providing a definition somewhere.

It is impossible to determine which of the function templates
is being specialized. This problem is related to the discussion
of issue 229, in which one of the objections
raised against partial specialization of function templates is
that it is not possible to determine which template is being
specialized.

Notes from 10/01 meeting:

It was decided that while this is true, it's not a problem. You
can't call such functions anyway; the call would be ambiguous.

662.
Forming a pointer to a reference type

The Standard currently specifies (7.1.3
[dcl.typedef] paragraph 9,
14.3.1
[temp.arg.type] paragraph 4) that an attempt to create a
reference to a reference (via a typedef or template type
parameter) is effectively ignored. The same is not true of an attempt
to form a pointer to a reference; that is, assuming that T is
specified to be a reference type,

It would be more consistent to allow pointers to references to
collapse in the same way that references to references do.

Rationale (February, 2008):

In the absence of a compelling need, the CWG felt that it was
better not to change the existing rules. Allowing this case could
cause a quiet change to the meaning of a program, because attempting
to create a pointer to a reference type is currently a deduction
failure.

99.
Partial ordering, references and cv-qualifiers

Some compilers treat this as ambiguous; others prefer f(const T&).
The question turns out to revolve around whether
14.8.2.1
[temp.deduct.call]
paragraph 2 says what it ought to regarding the removal of cv-qualifiers
and reference modifiers from template function parameters in
doing type deduction.

John Spicer:
The partial ordering rules as originally proposed specified that, for
purposes of comparing parameter types, you remove a top level reference,
and after having done that you remove top level qualifiers. This is not
what is actually in the IS however. The IS says that you remove top
level qualifiers and then top level references.

The original rules were intended to prefer f(A<T>) over f(const T&).

Rationale (10/99): The Standard correctly reflects the intent
of the Committee.

211.
Constructors should not be allowed to return normally after an exception

The grammar should be changed so that constructor
function-try-blocks must end with a
throw-expression.

Rationale (04/00):

No change is needed. It is already the case that flowing off the
end of a function-try-block of a constructor rethrows the
exception, and return statements are prohibited in
constructor function-try-blocks
(15.3
[except.handle] paragraphs 15-16.

Does A::~A() ever execute here?
(Or, in case two constructions are done,
are there two destructions done?) Is it implementation-defined, analogously
to whether the stack is unwound before terminate() is called
(15.3
[except.handle]
paragraph 9)?

Or what if an exception specification is violated? There are several
different scenarios here:

The case where u() exits is presumably similar to the terminate() case.
But in the cases where the program goes on, A::~A() should be called
for the thrown object at some point. But where does this happen?
The standard doesn't really say. Since an exception is defined to
be "finished" when the unexpected() function exits, it seems to me that
is where A::~A() should be called — in this case, as the throws of
new (or what will become new) exceptions are made out of u().
Does this make sense?

Rationale (10/99): Neither std::exit(int) nor
std::abort() destroys temporary objects, so the exception
temporary is not destroyed when no handler is found. The original
exception object is destroyed when it is replaced by an
unexpected() handler. The Standard is sufficiently clear
on these points.

Also I see one more possible solution: to forbid objects with ambiguous
base classes to be "exceptional objects" (for example Borland C++ goes this
way) but it seems to be unnecessary restrictive.

Notes from the 10/01 meeting:

The Core Working Group did not feel this was a significant problem.
Catching either of the ambiguous base classes would be surprising, and
giving an error on throwing an object that has an ambiguous base class
would break existing code.

593.
Falling off the end of a destructor's function-try-block handler

If control reaches the end of handler in a
destructor's function-try-block, the exception is rethrown
(15.3
[except.handle] paragraph 15). Because of the danger
of destructors that throw exceptions, would it be better to
treat this case as an implicit return; statement, as in
a function body? There could be a transitional period, perhaps
using conditionally-supported behavior or the like, before
mandating the change.

Rationale (October, 2006):

The CWG felt that the current behavior is clearly specified and
reflects the intention of the Committee at the time the rules were
adopted. Possible changes to these rules should be pursued through
the Evolution Working Group.

346.
Typo in 15.4

15.4
[except.spec] paragraph 13 contains the following text.
I believe 'implicitLY' marked below should be replaced with
'implicit.'

An implicitly declared special member
function (clause 12
[special])
shall have an exception-specification. If f is an implicitly
declared default constructor, copy constructor, destructor, or copy
assignment operator, its implicit exception-specification
specifies the type-id T if and only if T is allowed by the
exception-specification of a function directly invoked
by f's implicitly definition;
f shall allow all exceptions if any function it directly invokes
allows all exceptions, and f shall allow no exceptions if
every function it directly invokes allows no exceptions. [Example:

Furthermore, if A::~A() or B::~B() were virtual, D::~D() would not be as
restrictive as that of A::~A, and the program would
be ill-formed since a function that overrides a virtual function from a
base class shall have an exception-specification at least as
restrictive as that in the base class. ]

The example code shows structs whose destructors have exception
specifications which throw certain types. There is no defect here, but
it doesn't sit well with our general advice elsewhere that destructors
should not throw. I wish I could think of some other way to illustrate
this section.

37.
When is uncaught_exception() true?

The term "throw exception" seems to sometimes refer to an expression
of the form "throwexpr" and
sometimes just to the "expr"
portion thereof.

As a result it is not quite clear to me
whether when "uncaught_exception()"
becomes true: before or after the temporary
copy of the value of "expr".

Is there a definite consensus about that?

Rationale:
The standard is sufficiently clear; the phrase "to be thrown" indicates
that the throw itself (which includes the copy to the temporary object)
has not yet begun. The footnote in
15.5.1
[except.terminate]
paragraph 1 reinforces
this ordering.

584.
Unions and aliasing

an aggregate or union type that includes one of the
aforementioned types among its members (including, recursively, a
member of a subaggregate or contained union),

Note that it is a literal copy from the C standard, but this is of
course not the problem.

In C, union is not defined as an aggregate type. Therefore it is
appropriate to say “aggregate or union.” But things
changed in C++: aggregate type includes union type now (though not all
unions are aggregates), and it becomes clear that the
“union” in “aggregate or union” is redundant
and should be deleted.

The above cited paragraph could be changed to:

an aggregate type that includes one of the aforementioned
types among its members (including, recursively, a member of a
subaggregate)

Rationale (October, 2006):

As noted in the issue, not all unions are aggregates, but those
that are not aggregates still allow aliasing. That part of the
specification would be lost with the suggested change.

50.
Converting pointer to incomplete type to same type

In 3.2
[basic.def.odr]
paragraph 4
bullet 4, it's presumably the case that a conversion to T*
requires that T be complete only if the conversion is from a different
type. One could argue that there is no conversion (and therefore
the text is accurate as it stands) if a cast does not change the type of
the expression, but it's probably better to be more explicit here.

The idea is that the enumerator "next" in each class is the next available
value for enumerators in further derived classes.

If we had written

enum { d = next, e, f, next };

I think we would run afoul of 3.3.6
[basic.scope.class]
:

A name N used in a class S shall refer to
the same declaration in its context and when re-evaluated in the completed
scope of S. No diagnostic is required for a violation of this
rule.

But in the original code, we don't have an unqualified "next" that refers
to anything but the current scope. I think the intent was to allow the
code, but I don't find the wording clear on on that point.

Is there another section that makes it clear whether the original code
is valid? Or am I being obtuse? Or should the quoted section say "An unqualified
name N used in a class ..."?

Rationale (04/99): It is sufficiently clear that "name"
includes qualified names and hence the usual lookup rules make this
legal.

Suggested resolution: Change the first sentence of
3.4.1
[basic.lookup.unqual] paragraph 2 to read:

The declarations from the namespace nominated by a
using-directive become visible in the scope in which the
using-directive appears after the using-directive.

Notes from the 4/02 meeting:

After a lot of discussion of possible wording changes, we decided
the wording should be left alone. 3.4.1
[basic.lookup.unqual]
paragraph 2 is not intended to be a full specification; that's in
7.3.4
[namespace.udir] paragraph 1. See also
3.3.5
[basic.scope.namespace] paragraph 1.

Is this an error in the description of unions in argument-dependent lookup?

Also, this section is written as if unions were distinct from classes.
So adding unions to the "associated classes" requires either rewriting
the section so that "associated classes" can include unions, or changing
the term to be more inclusive, e.g. "associated classes and unions" or
"associated types".

Jason Merrill: Perhaps in both cases, the standard text was intended
to only apply to anonymous unions.

[Note: the lookup rules for operators in expressions are
different than the lookup rules for operator function names
in a function call, ...

In particular, consider the above call to "Y() + unsigned" and please
help me step through 13.3.1.2
[over.match.oper] paragraph 3:

... for a binary operator @ with a left operand of a type whose
cv-unqualified version is T1 and a right operand of a type
whose cv-unqualified version is T2,

OK so far, here @ is +, and T1 is N1::X::Y.

three sets of candidate functions, designated member candidates,
non-member candidates and built-in candidates, are constructed
as follows:

[and later are union'd together to get the candidate list]

If T1 is a class type, the set of member candidates is the result
of the qualified lookup of T1::operator@ (over.call.func);
otherwise, the set of member candidates is empty.

So there is one member candidate, N1::X::Y::operator+.

The set of non-member candidates is the result of the unqualified
lookup of operator@ in the context of the expression according to
the usual rules for name lookup in unqualified function calls
(basic.lookup.argdep) except that all member functions are ignored.

*** This is the question: What does that last phrase mean? Does it mean:

a) first apply the usual ADL rules to generate a candidate list, then
ignore any member functions in that list (this is what I believe and
hope it means, and in particular it means that the presence of a member
will suppress names that ADL would otherwise find in the associated
namespaces); or

b) something else?

In short, does N2::operator+ make it into the candidate list? I think it
shouldn't. Am I right?

John Spicer:
I believe that the answer is sort-of "a" above. More specifically, the
unqualified lookup consists of a "normal" unqualified lookup and ADL.
ADL always deals with only namespace members, so the "ignore members
functions" part must affect the normal lookup, which should ignore class
members when searching for an operator.

I suspect that the difference between compilers may have to do with details
of argument-dependent lookup. In the example given, the argument types
are "N1::X<N2::Z>::Y" and "unsigned int". In order for N2::operator+ to
be a candidate, N2 must be an associated namespace.

N1::X<N2::Z>::Y is a class type, so
3.4.2
[basic.lookup.argdep] says that its associated classes are
its direct and indirect base classes, and its namespaces are the namespaces
of those classes. So, its associated namespace is just N1.

3.4.2
[basic.lookup.argdep] also says:

If T is a template-id, its associated namespaces and classes are the
namespace in which the template is defined; for member templates,
the member template's class; the namespaces and classes associated
with the types of the template arguments provided for template type
parameters (excluding template template parameters); the namespaces
in which any template template arguments are defined; and the
classes in which any member templates used as template template
arguments are defined. [Note: non-type template arguments do not
contribute to the set of associated namespaces. ]

First of all, there is a problem with the term "is a template-id". template-id
is a syntactic constuct and you can't really talk about a type being a
template-id. Presumably, this is intended to mean "If T is the type of a
class template specialization ...".
But does this apply to N1::X<N2::Z>::Y?
Y is a class nested within a class template specialization. In addition,
its base class is a class template specialization.

I think this raises two issues:

Should the enclosing class(es) of a class, and their template argument lists
(if any) contribute to the associated classes/namespaces for ADL?

Should the template argument lists of base classes contribute to the
associated classes/namespaces for ADL?

Notes from the April 2003 meeting:

The ADL rules in the standard sort of look at if they are fully
recursive, but in fact they are not; in some cases, enclosing classes
and base classes are considered, and in others they are not.
Microsoft and g++ did fully-recursive implementations, and
EDG and IBM did it the other way. Jon Caves reports that Microsoft saw
no noticeable difference (e.g., no complaints from customers
internal or external) when they made this change, so we believe
that even if the rules are imperfect the way they are in the
standard, they are clear and the imperfections are small enough
that programmers will not notice them. Given that, it seemed
prudent to make no changes and just close this issue.

The reason for this is that 3.4.3.1
[class.qual]
paragraph 2 says that S::S is “considered to name
the constructor,” which is not a template and thus cannot
accept a template argument list. On the other hand, the
second S in S::~S finds the
injected-class-name, which “can be used with or without a
template-argument-list” (14.6.1
[temp.local]
paragraph 1) and thus satisfies the requirement to name the
destructor's class (12.4
[class.dtor] paragraph 1).

Would it make sense to allow the template-argument-list
in the constructor declaration and thus make the language just a
little easier to use?

Rationale (July, 2007):

The CWG noted that the suggested change would be confusing in the
case where the class template had both template and non-template
constructors.

269.
Order of initialization of multiply-defined static data members
of class templates

According to 3.2
[basic.def.odr] paragraph 5, it is possible
for a static data member of a class template to be defined more than
once in a given program provided that each such definition occurs in a
different translation unit and the ODR is met.

The specialization exp<char>::m_data is implicitly
instaniated in both translation units, hence (14.7.1
[temp.inst] paragraph 1) its initialization occurs. And for both
definitions of exp<T>::m_data the ODR is met. According
to 3.6.2
[basic.start.init] paragraph 1:

Objects with static storage duration defined in namespace scope in the
same translation unit and dynamically initialized shall be initialized
in the order in which their definition appears in the translation
unit.

But for exp<T>::m_data we have two definitions. Does
it mean that both g_data1 and g_data3 are guaranteed
to be dynamically initialized before
exp<char>::m_data?

Suggested Resolution:
Insert the following sentence before the last two sentences of
3.2
[basic.def.odr] paragraph 5:

In the case of D being a static data member of a class
template the following shall also hold:

for a given (not explicit) specialization of D initialized dynamically
(3.6.2
[basic.start.init]), the accumulated set of objects initialized dynamically
in namespace scope before the specialization of D shall be the same in every
translation unit that contains the definition for this specialization.

Notes from 10/01 meeting:

It was decided that this issue is not linked to
issue 270 and that there is no problem, because
there is only one instantiation (see 2.1
[lex.phases] paragraph 8).

465.
May constructors of global objects call exit()?

The subject line pretty much says it all. It's a possibility that
hadn't ever occurred to me. I don't see any prohibition in the
standard, and I also don't think the possibility introduces any logical
inconsistencies. The proper behavior, presumably, would be to go
through the list of already-constructed objects (not including the
current one, since its constructor wouldn't have finished executing)
and destroy them in reverse order. Not fundamentally hard, and I'm
sure lots of existing implementations already do that.

I'm just not sure whether the standard was intended to support this, or
whether it's just that nobody else thought of it either. If the
former, then a non-normative note somewhere in
3.6.2
[basic.start.init] might be nice.

Rationale (October 2004):

There is nothing in the Standard to indicate that this usage
is prohibited, so it must be presumed to be permitted.

However the standard does not seem to prohibit the same operations
on base sub-objects.

struct D: B{ ... } d;
B* pb = &d;
pb->~B();
new(pb) B;

However if B and/or D have virtual member
functions or virtual bases, it is unlikely that this code will result
in a well-formed D object in current implementations (note
that the various lines may be in different functions).

Suggested resolution: 12.4
[class.dtor] should be
modified so that explicit destruction of base-class sub-objects be
made illegal, or legal only under some restrictive conditions.

290.
Should memcpy be allowed into a POD with a const member?

Following the definition in 9
[class] paragraph 4
the following is a valid POD (actually a POD-struct):

struct test
{
const int i;
};

The legality of PODs with const members is also implied by the text of
5.3.4
[expr.new] paragraph 15 bullet 1, sub-bullet 2 and
12.6.2
[class.base.init] paragraph 4 bullet 2.

3.9
[basic.types] paragraph 3 states that

For any POD type
T, if two pointers to T point to distinct objects
obj1 and obj2, if the value of obj1 is copied
into obj2, using the memcpy library function, obj2
shall subsequently hold the same value as obj1.

[Note: this text was changed by TC1, but the essential point
stays the same.]

An integral constant expression rvalue of integer type that evaluates
to zero (called a /null pointer constant/) can be converted to a
pointer type.

Stroustrup appears to agree with me -- he states (3rd edition page 88):

In C, it has been popular to define a macro NULL to represent the zero
pointer. Because of C++`s tighter type checking, the use of plain 0,
rather than any suggested NULL macro, leads to fewer problems. If you
feel you must define NULL, use:

I have reported this as a bug
(http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13867), but the gcc team
states that 4.10 requires that a null pointer constant must be an rvalue
-- and no implicit conversion from an lvalue to an rvalue is required
(http://gcc.gnu.org/bugzilla/show_bug.cgi?id=396):

a null pointer constant is an integral constant expression rvalue that
evaluates to zero [4.10/1] in this case `null' is an lvalue. The
standard does not specify that lvalue->rvalue decay happens here, so
`null' is not a null pointer constant.

I disagree with the gcc teams interpretation -- I don't see why
3.10
[basic.lval] doesn't apply:

Whenever an lvalue appears in a context where an rvalue is expected,
the lvalue is converted to an rvalue;

The insertion of the word rvalue appears to have occurred during
standardization -- it is not present in either Stroustrup 2nd edition or
the 3rd edition. Does the committee deliberately intend to exclude an
lvalue as a null pointer constant by adding the word rvalue? If so, it
leads to the rather bizarre fact that "null" is not a null pointer
constant, but "null + 0" is!

Notes from the March 2004 meeting:

We think this is just a bug in gcc. The const variable does
get converted to an rvalue in this context. This case is not
really any different than cases like

const int null = 0;
int i = null;

or

const int i = 1;
int a[i];

(which are accepted by gcc).
No one would argue that the second lines of those examples
are invalid because the variables are lvalues, and yet the conversions
to rvalue happen implicitly for the same reason cited above -- the
contexts require an rvalue.

303.
Integral promotions on bit-fields

Paragraph 3 of section 4.5
[conv.prom] contains a statement
saying that if a bit-field is larger than int or unsigned int, no integral
promotions apply to it. This phrase needs further clarification, as it
is hardly possible to fugure out what it means. See below.

Assuming a machine with a size of general-purpose register equal 32
bits (where a byte takes up 8 bits) and a C++ implementation where an
int is 32 bits and a long is 64 bits. And the following snippet of
code:

Does the standard prohibit the implementation from promoting field1's
value into two general purpose registers? And imposes a burden of
using shift machine instructions to work with the field's value? What
else could that phrase mean?

Either alternative is implementation specific, so I don't understand
why the phrase "If the bit-field is larger yet, no integral promotions
apply to it" made it to the standard.

Notes from 10/01 meeting:

The standard of course does not dictate what an implementation
might do with regard to use of registers or shift instructions in
the generated code. The phrase cited means only that a larger
bit-field does not undergo integral promotions, and therefore it
retains the type with which it was declared (long in
the above example). The Core Working Group judged that this
was sufficiently clear in the standard.

Note that 9.6
[class.bit] paragraph 1
indicates that any bits in excess of the size of the underlying type
are padding bits and do not participate in the value representation.
Therefore the field1 bit field in the above example is not
capable of holding the indicated values, which require more than 32 bits.

566.
Conversion of negative floating point values to integer type

An rvalue of a floating point type can be converted to an rvalue of an
integer type. The conversion truncates; that is, the fractional part
is discarded.

Here, the concepts of “truncation” and
“fractional part” seem to be used without precise
definitions. When -3.14 is converted into an integer, is the
truncation toward zero or away from zero? Is the fractional part -0.14
or 0.86? The standard seem to give no clear answer to these.

Suggested resolution:

Replace “truncates” with “truncates toward
zero.”

Replace “the fractional part” with “the
fractional part (where that of x is defined
as x-floor(x) for nonnegative x
and x-ceiling(x) for negative x);” there
should be a better wording for this, or the entire statement
“that is, the fractional part is discarded” can be removed,
once the meaning of “truncation” becomes unambiguous as
above.

Rationale (October, 2006):

The specification is clear enough: “fractional part”
refers to the digits following the decimal point, so that -3.14
converted to int becomes -3.

71.
Incorrect cross reference

An operator expression can, according to
5
[expr]
paragraph 2, require transformation into function call syntax. The
reference in that paragraph is to
13.5
[over.oper]
, but it should be to
13.3.1.2
[over.match.oper]
.

Whether the definition of table is well-formed hinges on whether
false is an integral constant expression.

I think that it should be, and that failure to make it so was just
an oversight.

Rationale (04/99): A careful reading of
5.19
[expr.const]
indicates that all types of
literals can appear in integral constant expressions, but
floating-point literals must immediately be cast to an integral type.

487.
Operator overloading in constant expressions

In particular, except in sizeof expressions, functions,
class objects, pointers, or references shall not be used, and
assignment, increment, decrement, function-call, or comma
operators shall not be used.

Given a case like

enum E { e };
int operator+(int, E);
int i[4 + e];

does this mean that the overloaded operator+ is not
considered (because it can't be called), or is it selected by
overload resolution, thus rendering the program ill-formed?

Rationale (April, 2005):

All expressions, including constant expressions, are subject to
overload resolution. The example is ill-formed.

The fact that a static_cast is defined, more or less,
as an initialization suggests that a check ought to be made.

One tricky point: this is another case where the general rule that
the reverse of an implicit cast is allowed as a static_cast
bites you -- the reverse conversion doesn't drop exception
specifications, and so is okay. Perhaps this should be treated
like casting away constness.

Mike Miller comments
:
I don't think that case can arise. According to 15.4
[except.spec],

An exception-specification shall appear only on a function
declarator in a function, pointer, reference, or pointer to
member declaration or definition.

We strengthened that in issue 87
(voted to DR status in Copenhagen) to

An exception-specification shall appear only on a function
declarator for a function type, pointer to function type,
reference to function type, or pointer to member function
type that is the top-level type of a declaration or
definition, or on such a type appearing as a parameter or
return type in a function declarator.

As I read that, you can't put an exception-specification on the
type-id in a static_cast, which means that a static_cast can
only weaken, not strengthen, the exception specification.

The core WG discussed this at the 10/01 meeting and agreed.

Note (March, 2008):

The Evolution Working Group recommended closing this issue with no
further consideration. See paper J16/07-0033 = WG21 N2173.

610.
Computing the negative of 0U

In 5.3.1
[expr.unary.op], part of paragraph 7 describes
how to compute the negative of an unsigned quantity:

The negative of an unsigned quantity is computed by subtracting
its value from 2n, where n is the number
of bits in the promoted operand. The type of the result is the
type of the promoted operand.

According to this method, -0U will get the value
2n - 0 = 2n, where
n is the number of bits in an unsigned int. However,
2n is obviously out of the range of values
representable by an unsigned int and thus not the actual value
of -0U. To get the result, a truncating conversion
must be applied.

Rationale (April, 2007):

As noted in the issue description, a “truncating
conversion” is needed. This conversion is supplied without
need of an explicit mention, however, by the nature of unsigned
arithmetic given in 3.9.1
[basic.fundamental] paragraph 4:

Unsigned integers, declared unsigned, shall obey the laws of
arithmetic modulo 2n where n is the number of
bits in the value representation of that particular size of
integer.

31.
Looking up new/delete

If a delete-expression begins with a unary :: operator, the
deallocation function's name is looked up in global scope. Otherwise,
if the delete-expression is used to deallocate a class object whose static
type has a virtual destructor, the deallocation function is the one found
by the lookup in the definition of the dynamic type's virtual destructor
(12.4
[class.dtor]
).
Otherwise, if the delete-expression is used to deallocate
an object of class T or array thereof, the static and dynamic types of
the object shall be identical and the deallocation function's name is
looked up in the scope of T. If this lookup fails to find the name, the
name is looked up in the global scope. If the result of the lookup is ambiguous
or inaccessible, or if the lookup selects a placement deallocation function,
the program is ill-formed.

I contrast that with 5.3.4
[expr.new]
paragraphs 16 and 17:

If the new-expression creates an object or an array of objects
of class type, access and ambiguity control are done for the allocation
function, the deallocation function (12.5
[class.free]
), and the constructor
(12.1
[class.ctor]
). If the new-expression creates an array of objects of class
type, access and ambiguity control are done for the destructor (12.4
[class.dtor]
).

If any part of the object initialization described above terminates
by throwing an exception and a suitable deallocation function can be found,
the deallocation function is called to free the memory in which the object
was being constructed, after which the exception continues to propagate
in the context of the new-expression. If no unambiguous matching deallocation
function can be found, propagating the exception does not cause the object's
memory to be freed. [Note: This is appropriate when the called allocation
function does not allocate memory; otherwise, it is likely to result in
a memory leak. ]

I think nothing in the latter paragraphs implies that the deallocation
function found is the same as that for a corresponding delete-expression.
I suspect that may not have been intended and that the lookup should occur
"as if for a delete-expression".

Rationale:

Paragraphs 16 through 18 are sufficiently correct and unambiguous as
written.

130.
Sequence points and new-expressions

Clause 5
[expr]
paragraph 4 appears to
grant an implementation the right to generate code for a function
call like

f(new T1, new T2)

in the order

allocate memory for the T1 object

allocate memory for the T2 object

call the T1 constructor

call the T2 constructor

call f

However, 5.3.4
[expr.new]
paragraph 17
seems to require the deallocation of the storage for an object only
if part of the initialization of that object terminates with an
exception. Given the ordering above, this specification would
appear to allow the memory for the T2 object to be leaked
if the T1 constructor throws an exception.

Suggested resolution: either forbid the ordering above or expand
the requirement for reclaiming storage to include exceptions thrown
in all operations between the allocation and the completion of the
constructor.

Rationale (10/99): Even in the "traditional" ordering of the calls
to allocation functions and constructors, memory can still leak. For
instance, if T1 were successfully constructed and then the
construction of T2 were terminated by an exception, the
memory for T1 would be lost. Programmers concerned about
memory leaks will avoid this kind of construct, so it seems
unnecessary to provide special treatment for it to avoid the memory
leaks associated with one particular implementation strategy.

55.
Adding/subtracting pointer and enumeration value

An expression of the form pointer + enum (see paragraph 5) is not given
meaning, and ought to be, given that paragraph 2 of this section makes
it valid. Presumably, the enum value should be converted to an integral
value, and the rest of the processing done on that basis. Perhaps
we want to invoke the integral promotions here.

(It was later pointed out that the builtin operator
T* operator+(T*, ptrdiff_t)
(13.6
[over.built]
paragraph 13) is
selected by overload resolution. Consequently, according to
13.3.1.2
[over.match.oper]
paragraph 7,
the operand of enumeration type is converted to ptrdiff_t
before being interpreted according to the rules in
5.7
[expr.add]
.)

567.
Can size_t and ptrdiff_t be larger than long?

Code that was portable in C90 and C++98 is no longer portable with
the introduction of data types longer than long; code that
could previously cast size_t and ptrdiff_t to
long without loss of precision (because long was
the largest type) can no longer rely on that idiom.

The CWG discussed this during the Berlin (April, 2006) meeting. The
general consensus was that this was unavoidable: there are valid
reasons for implementations to keep long at a size less than
that required for address arithmetic.

See paper J16/06-0053 = WG21 N1983, which also suggests the
possibility of required diagnostics for problematic cases as an
alternative to restricting the size of size_t and
ptrdiff_t.

Rationale (October, 2006):

This is not an area in which the Standard should override the
decisions of implementors who wish to maintain the size of
long for backward compatibility but need a
larger size_t to deal with expanded address spaces. Also,
diagnostics of the sort described are better treated as quality of
implementation issues rather than topics for standardization.

467.
Jump past initialization of local static variable

When jumping past initialization of a local static variable the
value of the static becomes indeterminate. Seems like this
behavior should be illegal just as it is for local variables
with automatic linkage.

A program that jumps from a point where a local variable with automatic
or static storage duration is not in scope to a point where it is in
scope is
ill-formed unless the variable has POD type (3.9) and is declared without
an initializer (8.5).

This would imply "static X a = 1;" should be flagged as an error.
Note that this behavior a may be a "quality of implementation issue"
which may be covered in 6.7 P4. Paragraph 4 seems to make the
choice of static/dynamic initialization indeterminate.
Making this an error and thus determinate seems the correct thing
to do since that is what is already required of automatic variables.

Steve Adamczyk:
Some version of this may be appropriate, but it's common to have code
that is executed only the first time it is reached, and to have
an initialization of a static variable inside such a piece of code.
In such a case, on executions after the first there is indeed a
jump over the declaration, but the static variable is correctly
initialized -- it was initialized the first time the routine
was called.

The CWG sees no reason to change this specification. Local
static variables are different from automatic variables:
automatic variables, if not explicitly initialized, can have
indeterminate (“garbage”) values, including trap
representations, while local static variables are subject to zero
initialization and thus cannot have garbage values.

The latitude granted to implementations regarding performing
dynamic initialization of local static objects as if it were
static initialization is exactly parallel to namespace scope
objects (3.6.2
[basic.start.init]), as are the restrictions
on programmer assumptions.

435.
Change "declararation or definition" to "declaration"

Because a definition is also a declaration, it might make sense
to change uses of "declaration or definition" to simply "declaration".

Notes from the March 2004 meeting:

Jens Maurer prepared drafting for this issue, but we find ourselves
reluctant to actually make the changes. Though correct, they seemed
more likely to be misread than the existing wording.

Proposed resolution:

Remove in 1.3
[intro.defs] “parameter”
the indicated words:

an object or reference declared as part of a function declaration or
definition, or in the catch clause of an exception handler, that
acquires a value on entry to the function or handler; ...

Remove in 14.1
[temp.param]
paragraph 10 the indicated words:

The set of default template-arguments available for use with a
template declaration or definition is obtained by
merging the default arguments from the definition (if in scope) and
all declarations in scope in the same way default function arguments
are (...).

Remove in 14.6
[temp.res] paragraph 2 the indicated words:

A name used in a template declaration or definition
and that is dependent on a template-parameter is assumed not to
name a type unless the applicable name lookup finds a type name or the
name is qualified by the keyword typename.

Remove in 14.6.4.1
[temp.point] paragraph 1 the indicated words:

Otherwise, the point of instantiation for such a specialization
immediately follows the namespace scope declaration or
definition that refers to the specialization.

Remove in 14.6.4.1
[temp.point] paragraph 3 the indicated words:

Otherwise, the point of instantiation for such a specialization
immediately precedes the namespace scope declaration or
definition that refers to the specialization.

Remove in 14.7.3
[temp.expl.spec] paragraph 21 the indicated words:

Default function arguments shall not be specified in a declaration
or a definition for one of the following explicit
specializations:

...

[Note: default function arguments may be specified in the
declaration or definition of a member function of a
class template specialization that is explicitly specialized. ]

[Note: a default template-argument cannot be specified in a
function template declaration or definition; ...]

Remove in 17.4.2.1
[using.headers]
paragraph 3 the indicated words:

A translation unit shall include a header only outside of any external
declaration or definition, and shall include the
header lexically before the first reference to any of the entities it
declares or first defines in that translation unit.

154.
Anonymous unions in unnamed namespaces

9.5
[class.union]
paragraph 3 implies
that anonymous unions in unnamed namespaces need not be declared
static (it only places that restriction on anonymous unions
"declared in a named namespace or in the global namespace").

However, 7.1.1
[dcl.stc]
paragraph 1 says
that "global anonymous unions... shall be declared static."
This could be read as prohibiting anonymous unions in unnamed
namespaces, which are the preferred alternative to the deprecated use
of static.

Rationale (10/99): An anonymous union in an unnamed
namespace is not "a global anonymous union," i.e., it is not a
member of the global namespace.

This is not a defect. Though there is a long history, going
back to the ARM, of use of the term "class declaration" to mean the
definition of the class, we believe "class definition" is clearer.
We have opened issue 379 to deal
with changing all other uses of "class declaration" to "class
definition" where appropriate.

412.
Can a replacement allocation function be inline?

A customer reports that when he attempts to replace
::operator new with
a user-defined function, the standard library calls the default
function by preference if the user-defined function is inline. I
believe that our compiler is correct, and that such a replacement
function isn't allowed to be inline, but I'm not sure there's
sufficiently explicit language in the standard.

In general, of course, the definition of an inline function must be
present in every translation unit where the function is called.
(7.1.2
[dcl.fct.spec],
par 4) It could be argued that this requirement doesn't quite address
replacement functions: what we're dealing with is the odd case where
we've already got one definition and the user is supplying a different
one. I'd like to see something specifically addressing the case of a
replacement function.

So what do we have? I see discussion of requirement for a replacement
::operator new in three places:
17.4.3.5
[replacement.functions],
18.5.1.1
[new.delete.single] par 2, and
3.7.3
[basic.stc.dynamic] par
2-3. I don't see anything explicitly saying that the replacement
function may not be inline. The closest I can find is
18.5.1.1
[new.delete.single] par 2,
which says that "a C++ program may define a function with this function
signature that displaces the default version defined by the C++
Standard library". One might argue that "with this function signature"
rules out inline, but that strikes me as a slight stretch.

422.
Is a typedef redeclaration allowed with a template type that might be the same?

There is an instantiation where the function is valid. Is an
implementation allowed to issue an error on the template declaration
because the types on the typedef are not the same
(7.1.3
[dcl.typedef])?

How about

typedef T x;
typedef T2 x;

?

It can be argued that these cases should be allowed because they
aren't necessarily wrong, but it can also be argued that there's no
reason to write things like the first case above, and if such
a case appears it's more likely to be a mistake than some kind
of intentional test that int and T are the same type.

Notes from the October 2003 meeting:

We believe that all these cases should be allowed, and that
errors should be required only when an instance of the template is
generated. The current standard wording does not seem to
disallow such cases, so no change is required.

643.
Use of decltype in a class member-specification

A class is considered a completely-defined object type (3.9
[basic.types]) (or complete type) at the closing } of the
class-specifier. Within the class member-specification,
the class is regarded as complete within function bodies, default
arguments, and exception-specifications (including such things
in nested classes). Otherwise it is regarded as incomplete within its
own class member-specification.

In particular, the return type of a member function is not listed
as a context in which the class type is considered complete; instead,
that case is handled as an exception to the general rule in
8.3.5
[dcl.fct] paragraph 6 requiring a complete type in
the definition of a function:

The type of a parameter or the return type for a function definition
shall not be an incomplete class type (possibly cv-qualified) unless
the function definition is nested within
the member-specification for that class (including definitions
in nested classes defined within the class).

These rules have implications for the use of decltype.
(The following examples use the not-yet-accepted syntax for specifying
the return type of a function after its declarator, but the questions
apply to the current syntax as well.) Consider:

9.3.2
[class.this] paragraph 1 allows use of this
only in the body of a non-static member function, and the return type
is not part of the function-body.

Do we want to change the rules to allow these kinds of
decltype expressions?

Rationale (February, 2008):

In the other cases where a class type is considered complete
within the definition of the class, it is possible to defer handling
the construct until the end of the definition. That is not possible
for types, as the type may be needed immediately in subsequent
declarations.

It was also noted that the primary utility of decltype is
in generic contexts; within a single class definition, other
mechanisms are possible (e.g., use of a member typedef in both the
declaration of the operand of the decltype and to replace
the decltype itself).

669.
Confusing specification of the meaning of decltype

if e is an id-expression or a class member
access (5.2.5
[expr.ref]), decltype(e) is the type
of the entity named by e.

There are two clarifications to this specification that would
assist the reader. First, it would be useful to have a note
highlighting the point that a parenthesized expression is neither
an id-expression nor a member access expression.

Second, the phrase “the type of the entity named
by e” is unclear as to whether cv-qualification in the
object or pointer expression is or is not part of that type.
Rephrasing this to read, “the declared type of the
entity,” or adding “(ignoring any cv-qualification in the
object expression or pointer expression),” would clarify the
intent.

Rationale (February, 2008):

The text is clear enough. In particular, both of these points are
illustrated in the last two lines of the example contrasting
decltype(a->x) and decltype((a->x)): in the
former, the expression has no parentheses, thus satisfying the
requirements of the first bullet and yielding the declared type of
A::x, while the second has parentheses, falling into the
third bullet and picking up the const from the object
expression in the member access.

A change was introduced into the language that made names first declared
in friend declarations "invisible" to normal lookups until such time that
the identifier was declared using a non-friend declaration. This is described
in 7.3.1.2
[namespace.memdef]
paragraph 3 and
11.4
[class.friend]
paragraph 9 (and perhaps other places).

The standard gives examples of how this all works with friend declarations,
but there are some cases with nonfriend elaborated type specifiers for
which there are no examples, and which might yield surprising results.

The problem is that an elaborated type specifier is sometimes a declaration
and sometimes a reference. The meaning of the following code changes depending
on whether or not friend class names are injected (visibly) into the enclosing
namespace scope.

Is this the desired behavior, or should
all elaborated type specifiers (and not just those of the form
"class-key identifier;") have the effect of finding
previously declared "invisible"
names and making them visible?

Mike Miller: That's not how I would categorize the effect of
"struct B;". That declaration introduces the name
"B" into namespace N
in exactly the same fashion as if the friend declaration did not exist.
The preceding friend declaration simply stated that, if a class
N::B were
ever defined, it would have friendly access to the members of
N::X. In
other words, the lookups in both "struct A*..." and
"struct B;" ignore
the friend declarations.

(The standard is schizophrenic on the issue of whether such friend declarations
introduce names into the enclosing namespace. 3.3
[basic.scope]
paragraph 4 says,

friend declarations (11.4
[class.friend]
) may introduce a (possibly not visible) name
into an enclosing name-space

friend declarations refer to functions or classes that are members
of the nearest enclosing namespace, but they do not introduce new names
into that namespace (7.3.1.2
[namespace.memdef]
).

Both of these are just notes; the normative text doesn't commit itself
either way, just stating that the name is not found until actually declared
in the enclosing namespace scope. I prefer the latter description; I think
it makes the behavior you're describing a lot clearer and easier to understand.)

John Spicer: The previous declaration of B is not completely
ignored though, because certainly changing "friend struct B;" to "friend
union B;" would result in an error when B was later redeclared as a struct,
wouldn't it?

Bill Gibbons: Right. I think the intent was to model this after
the existing rule for local declarations of functions (which dates back
to C), where the declaration is introduced into the enclosing scope but
the name is not. Getting this right requires being somewhat more rigorous
about things like the ODR because there may be declaration clashes even
when there are no name clashes. I suspect that the standard gets this right
in most places but I would expect there to be a few that are still wrong,
in addition to the one Mike pointed out.

Mike Miller: Regarding would result in an error when B
was later redeclared

I don't see any reason why it should. The restriction that the class-key
must agree is found in 7.1.6.3
[dcl.type.elab]
and is predicated on having found a matching
declaration in a lookup according to 3.4.4
[basic.lookup.elab]
.
Since a lookup of a name declared
only (up to that point) in a friend declaration does not find that name
(regardless of whether you subscribe to the "does-not-introduce" or "introduces-invisibly"
school of thought), there can't possibly be a mismatch.

I don't
think that the Standard's necessarily broken here. There is no requirement
that a class declared in a friend declaration ever be defined. Explicitly
putting an incompatible declaration into the namespace where that friend
class would have been defined is, to me, just making it impossible to define
— which is no problem, since it didn't have to be defined anyway. The
only error would occur if the same-named but unbefriended class attempted
to use the nonexisting grant of friendship, which would result in an access
violation.

(BTW, I couldn't
find anything in the Standard that forbids defining a class with a mismatched
class-key, only using one in an
elaborated-type-specifier. Is this a hole
that needs to be filled?)

John Spicer: This is what 7.1.6.3
[dcl.type.elab]
paragraph 3 says:

The class-key or enum keyword present in the
elaborated-type-specifier
shall agree in kind with the declaration to which the name in the
elaborated-type-specifier
refers. This rule also applies to the form of elaborated-type-specifier
that declares a class-name or friend class since it can be
construed as
referring to the definition of the class. Thus, in any
elaborated-type-specifier,
the enum keyword shall be used to refer to an enumeration (7.2
[dcl.enum]
),
the unionclass-key shall be used to refer to a union
(clause 9
[class]
),
and either the class or structclass-key
shall be used to refer to a class
(clause 9
[class]
) declared using the
class or structclass-key.

The latter part of this paragraph (beginning "This rule also applies...")
is somewhat murky to me, but I think it could be interpreted to say that

class B;
union B {};

and

union B {};
class B;

are both invalid. I think this paragraph is intended to say that. I'm
not so sure it actually does say that, though.

Mike Miller: Regarding I think the intent was to model this
after the existing rule for local declarations of functions (which dates
back to C)

Actually, that's not the C (1989) rule. To quote the Rationale from
X3.159-1989:

While it was generally agreed that it is poor practice to take advantage
of an external declaration once it had gone out of scope, some argued that
a translator had to remember the declaration for checking anyway, so why
not acknowledge this? The compromise adopted was to decree essentially
that block scope rules apply, but that a conforming implementation need
not diagnose a failure to redeclare an external identifier that had gone
out of scope (undefined behavior).

Regarding Getting this right requires being somewhat more rigorous

Yes, I think if this is to be made illegal, it would have to be done
with the ODR; the name-lookup-based current rules clearly (IMHO) don't
apply. (Although to be fair, the [non-normative] note in 3.3
[basic.scope]
paragraph 4 sounds as
if it expects friend invisible injection to trigger the multiple-declaration
provisions of that paragraph; it's just that there's no normative text
implementing that expectation.)

Bill Gibbons: Nor does the ODR currently disallow:

translation unit #1 struct A;
translation unit #2 union A;

since it only refers to class definitions, not declarations.

But the obvious form of the missing rule (all declarations of a class
within a program must have compatible struct/class/union keys) would also
answer the original question.

is ill-formed even though the second "f" is not a visible declaration.

Rationale (10/99): The main issue (differing behavior of
standalone and embedded elaborated-type-specifiers) is as
the Committee intended. The remaining questions mentioned in the
discussion may be addressed in dealing with related issues.

165.
Definitions of friends and block-scope externs

Members of a named namespace can also be defined outside that
namespace by explicit qualification
(3.4.3.2
[namespace.qual]
) of the name being
defined, provided that the entity being defined was already declared
in the namespace...

It is not clear whether block-scope extern declarations and
friend declarations are sufficient to permit the named
entities to be defined outside their namespace. For example,

Rationale (10/99): Entities whose names are "invisibly
injected" into a namespace as a result of friend declarations
are not "declared" in that namespace until an explicit declaration of
the entity appears at namespace scope. Consequently, the definitions
in the example are ill-formed.

The reason for this is that non-member allocation and deallocation
functions are required to be members of the global scope (3.7.3.1
[basic.stc.dynamic.allocation] paragraph 1, 3.7.3.2
[basic.stc.dynamic.deallocation]
paragraph 1), unqualified friend declarations declare names in the
innermost enclosing namespace (7.3.1.2
[namespace.memdef]
paragraph 3), and these functions cannot be declared in global scope
at a point where the friend declarations could refer to them using
qualified-ids because their second parameter is a member of the
class and thus can't be named before the class containing the friend
declarations is defined.

Possible solutions for this conundrum include invention of some
mechanism to allow a friend declaration to designate a namespace scope
other than the innermost enclosing namespace in which the friend class
or function is to be declared or to relax the innermost enclosing
namespace lookup restriction in 7.3.1.2
[namespace.memdef]
paragraph 3 for friend declarations that nominate allocation and
deallocation functions.

Rationale (April, 2006):

The CWG acknowledged that it is not always possible to move
code from the global scope into a namespace but felt that this
problem was not severe enough to warrant changing the language to
accommodate it. Possible solutions include moving the enumeration
outside the class or defining member allocation and deallocation
functions.

if the "template" keyword were allowed.
There was a discussion about whether a dependent name specified in a
using-declaration could be given an "is a type" attribute through the
typename keyword; the decision was to allow this. But I don't recall
if the "is a template" attribute was discussed.

Rationale (04/99): Any semantics associated with the
template keyword in using-declarations should be considered an
extension.

We decided to make no change and to close this issue as not-a-defect.
This is not needed functionality; the example above, for example, can
be written with ->template. This issue has been on the
issues list for years as an extension, and there has been no clamor
for it.

It was also noted that knowing that something is a template is
not enough; there's still the issue of knowing whether it is a
class or function template.

169.
template-ids in using-declarations

It is not clear whether this prohibition applies to the entity for
which the using-declaration is a synonym or to any name that
appears in the using-declaration. For example, is the
following code well-formed?

For name lookup, both declarations of f are visible and overloading cannot
distinguish between them. Has the compiler to check that these functions
are really the same function or is the program in error?

Is this valid because the typedef size_t refers to the same type in both
namespaces?

Rationale (04/99):
In
7.3.4
[namespace.udir]
paragraph 4:

If name lookup finds a declaration for a name in two different
namespaces, and the declarations do not declare the same entity and do
not declare functions, the use of the name is ill-formed.

The term entity applied to typedefs refers to the underlying type
or class (3
[basic]
, paragraph 3); therefore
both declarations of size_t declare the same entity and
the above example is well-formed.

107.
Linkage of operator functions

Steve Clamage:
I can't find anything in the standard that prohibits a language
linkage on an operator function. For example:

extern "C" int operator+(MyInt, MyInt) { ... }

Clearly it is a bad idea, you could have only one operator+
with "C" linkage in the entire program, and you can't call the function
from C code.

Mike Miller:
Well, you can't name an operator function in C code, but if
the arguments are compatible (e.g., not references), you can
call it from C code via a pointer. In fact, because the language
linkage is part of the function type, you couldn't pass the
address of an operator function into C code unless you could
declare the function to be extern "C".

Fergus Henderson:
In the general case, for linkage to languages other than C,
this could well make perfect sense.

Steve Clamage:

But is it disallowed (as opposed to being stupid), and if so, where
in the standard does it say so?

Mike Miller:
I don't believe there's a restriction. Whether that is because
of the (rather feeble) justification of being able to call an
operator from C code via a pointer, or whether it was simply
overlooked, I don't know.

Fergus Henderson:
I don't think it is disallowed. I also don't think there is any need
to explicitly disallow it.

Steve Clamage:
I don't think the standard is clear enough on this point. I'd
like to see a clarification.

I think either of these two clarifications would be appropriate:

A linkage specification on an operator function is ill-formed.

A linkage specification on an operator function is
well-formed, but the semantics (e.g. name mangling) are
implementation-defined. In addition, the rule about multiple
functions with the same name having "C" linkage applies.

could well make sense, if language xyzzy is sufficiently compatible with
C++, and the one-function rule only applies to extern "C", not to other
language linkages. Given that it might make sense to have general
language linkages for operators, is it worthwhile to make an exception
to the general rule by saying that you can have any language linkage
on an operator function except "C" linkage? I don't like exceptions to
general rules unless they're very well motivated, and I don't see
sufficient motivation to make one here.

Certainly this capability isn't very useful. There are lots
of things in C++ that aren't very useful but just weren't
worth special-casing out of the language. I think this falls
into the same category.

Mike Ball:
I DON'T want to forbid operator functions within an
extern "C". Rather I want to add operator functions to that sentence
in paragraph 4 of
7.5
[dcl.link]
which reads

A C language linkage is ignored for the names of class members and
the member function type of class member functions.

My reason is simple: C linkage makes a total hash of scope. Any "C" functions
declared with the same name in any namespace scope are the same function.
In other words, namespaces are totally ignored.

This provision was added in toward the end of the standardization process,
and was, I thought, primarily to make it possible to put the C library
in namespace std. Otherwise, it seems an unwarrented attack on the
very concept of scope. We (wisely) didn't force this on static member
functions, since it would essentially promote them to the global scope.

Now I think that programmers think of operator functions as essentially
part of a class. At least for one very common design pattern they are
treated as part of the class interface. This pattern is the reason we
invented Koenig lookup for operator functions.

What happens when such a class definition is included, deliberately or
not, in an extern "C" declaration? The member operators continue to
work, but the non-member operators can suddenly get strange and
hard to understand messages. Quite possibly, they get the messages
only when combined with other classes in other compilation units.
You can argue that the programmer shouldn't put the class header
in a linkage delaration in the first place, but I can still find books
that recommend putting `extern "C"' around entire header files,
so it's going to happen.

I think that including operator functions in the general exclusion from
extern "C" doesn't remove a capability, rather it ensurs a capability
that programmers already think they have.

Rationale (10/00):

The benefits of creating an exception for operator functions
were outweighed by the complexity of adding another special case
to the rules.

Note (March, 2008):

The Evolution Working Group recommended closing this issue with
no further consideration. See paper J16/07-0033 = WG21 N2173.

168.
C linkage for static member functions

A C language linkage is
ignored for the names of class members and the member function types of
class member functions.

This makes good sense, since C linkage names
typically aren't compatible with the naming used for member functions at
link time, nor is C language linkage function type necessarily compatible
with the calling convention for passing this to a non-static member
function.

But C language linkage type (not name) for a static member function is
invaluable for a common programming idiom. When calling a C function that
takes a pointer to a function, it's common to use a private static member
function as a "trampoline" which retrieves an object reference (perhaps by
casting) and then calls a non-static private member function. If a static
member function can't have a type with C language linkage, then a global or
friend function must be used instead. These alternatives expose more of a
class's implementation than a static member function; either the friend
function itself is visible at namespace scope alongside the class definition
or the private member function must be made public so it can be called by a
non-friend function.

Suggested Resolution: Change the sentence cited above
to:

A C language linkage is ignored for the names of class members and the
member function types of non-static class member functions.

The example
need not be changed because it doesn't involve a static member function.

The following workaround accomplishes the goal of not exposing
the class's implementation, but at the cost of significant
superstructure and obfuscation:

358.
Namespaces and extern "C"

The two declarations of f refer to the same external function,
but is this a valid way to declare and define f?

And is the definition of f considered to be in namespace N
or in the global namespace?

Notes from October 2002 meeting:

Yes, this example is valid. See 7.5
[dcl.link]
paragraph 6, which contains a similar example with the definition in
the global namespace instead.
There is only one f, so the question of whether the definition
is in the global namespace or the namespace N is not meaningful.
The same function is found by name lookup whether it is found
from the declaration in namespace N or the declaration in
the global namespace, or both (7.3.4
[namespace.udir]
paragraph 4).

333.
Ambiguous use of "declaration" in disambiguation section

In deciding whether a construct is an object declaration or
a function declaration, 8.2
[dcl.ambig.res] contains the following
gem: "In that context, the choice is between a function declaration
[...] and an object declaration [...]
Just as for the ambiguities mentioned in 6.8
[stmt.ambig],
the resolution is to
consider any construct that could possibly be a declaration
a declaration."

To what declaration do the last two "declarations" refer? Object,
function, or (following from the syntax) possibly parameter
declarations?

Notes from the 4/02 meeting:

This is not a defect. Section 8.2
[dcl.ambig.res] reads:

The ambiguity arising from the similarity between a function-style
cast and a declaration mentioned in 6.8
[stmt.ambig]
can also occur in the context
of a declaration. In that context, the choice is between a function
declaration with a redundant set of parentheses around a parameter
name and an object declaration with a function-style cast as the
initializer. Just as for the ambiguities mentioned in
6.8
[stmt.ambig], the
resolution is to consider any construct that could possibly be a
declaration a declaration.

The wording "any construct" in the last sentence is not limited
to top-level constructs. In particular, the function declaration
encloses a parameter declaration, whereas the object declaration
encloses an expression. Therefore, in case of ambiguity between
these two cases, the declaration is parsed as a function declaration.

The problem concerns the line marked /* Line X */, which is an
ambiguous declarations for either an object or a function.
The clause that governs this ambiguity is 8.2
[dcl.ambig.res]
paragraph 1, and reads:

The ambiguity arising from the similarity between a function-style
cast and a declaration mentioned in 6.8
[stmt.ambig]
can also occur in the context
of a declaration. In that context, the choice is between a function
declaration with a redundant set of parentheses around a parameter
name and an object declaration with a function-style cast as the
initializer. Just as for the ambiguities mentioned in
6.8
[stmt.ambig], the
resolution is to consider any construct that could possibly be a
declaration a declaration. [Note: a declaration can be explicitly
disambiguated by a nonfunction-style cast, by a = to indicate
initialization or by removing the redundant parentheses around the
parameter name. ]

Based on this clause there are two possible interpretations of the
declaration in line X:

The declaration of latt declares a function with a return value of
the type Lattice and taking three arguments. The type of the first two
arguments is Point and each of these arguments is followed by a
parameter name in redundant parentheses. The type of the third
argument can not be determined, because it is a literal.
This will result in a syntax error.

The declaration of latt declares an object, because the other option
(a function declaration) would result in a syntax error.

Note that the last sentence before the "[Note:" is not much help,
because both options are declarations.

Steve Adamczyk: a number of people replied to this posting
on comp.std.c++ saying that they did not see a problem. The
original poster replied:

I can't do anything but agree with your argumentation.
So there is only one correct interpretation of clause
8.2
[dcl.ambig.res] paragraph 1, but I
have to say that with some rewording, the clause can be made a lot
clearer, like stating explicitly that the entire declaration must be
taken into account and that function declarations are preferred over
object declarations.

I would like to suggest the following as replacement for the current
clause 8.2
[dcl.ambig.res] paragraph 1:

The ambiguity arising from the similarity between a functionstyle
cast and a declaration mentioned in
6.8
[stmt.ambig] can also occur in the context
of a declaration. In that context, the choice is between a function
declaration with a redundant set of parentheses around a parameter
name and an object declaration with a function-style cast as the
initializer. The resolution is to consider any construct that could
possibly be a function declaration a function declaration. [Note: To
disambiguate, the whole declaration might have to be examined to
determine if it is an object or a function declaration.] [Note: a
declaration can be explicitly disambiguated by a nonfunction-style
cast, by a = to indicate initialization or by removing the redundant
parentheses around the parameter name. ]

478.
May a function parameter be an array of an abstract class type?

8.3.4
[dcl.array] paragraph 1 says that a
declaration like that of sa is ill-formed:

T is called the array element type; this type
shall not be a reference type, the (possibly cv-qualified) type
void, a function type or an abstract class type.

On the other hand, 8.3.5
[dcl.fct] paragraph 3
says that the type of sa is adjusted to S*,
which would be permitted:

The type of each parameter is determined from its own
decl-specifier-seq and declarator. After
determining the type of each parameter, any parameter of type
“array of T” or “function returning
T” is adjusted to be “pointer to
T” or “pointer to function returning
T,” respectively.

It is not clear whether the parameter adjustment trumps the
prohibition on declaring an array of an abstract class type or
not. Implementations differ in this respect: EDG 2.4.2 and
MSVC++ 7.1 reject the example, while g++ 3.3.3 and Sun Workshop 8
accept it.

Rationale (April, 2005):

The prohibition in 8.3.4
[dcl.array] is absolute
and does not allow for exceptions. Even though such a type in a
parameter declaration would decay to an allowed type, the prohibition
applies to the type before the decay.

This interpretation is consistent with the resolution of
issue 337, which causes template type
deduction to fail if such types are deduced. It was also observed
that pointer arithmetic on pointers to abstract classes is very
likely to fail, and the fact that the programmer used array notation
to declare the pointer type is a strong indication that he/she
expected to use subscripting.

18.
f(TYPE) where TYPE is void should be allowed

Section: 8.3.5
[dcl.fct]
Status: NAD
Submitter: unknown
Date: unknown

8.3.5
[dcl.fct]
paragraph 2 says:

If the parameter-declaration-clause is empty, the function
takes no arguments. The parameter list (void) is equivalent to
the empty parameter list.

Can a typedef to void be used instead of the type void in the parameter
list?

Paragraph 9 of says that extra default arguments added after a
using-declaration but before a call are usable in the call, while
7.3.3
[namespace.udecl]
paragraph 9 says that
extra function overloads are not. This seems inconsistent, especially
given the similarity of default arguments and overloads.

Rationale (10/99): The Standard accurately reflects the
intent of the Committee.

In section 8.5.3
[dcl.init.ref], paragraph 5, there is
following note:

Note: the usual lvalue-to-rvalue (4.1), array-to-pointer (4.2), and
function-to-pointer (4.3) standard conversions are not needed, and
therefore are suppressed, when such direct bindings to lvalues are done.

There has been discussion on this issue on comp.lang.c++.moderated month
ago, see
http://groups.google.pl/groups?threadm=9bed99bb.0308041153.1c79e882%40posting.google.com
and there seems to be some confusion about it. I understand that note is
not normative, but apparently even some compiler writers are misled (try
above code snippets on few different compilers, and using different
compilation options - notably GCC 3.2.3 with -Wall -pedantic), thus it
should be cleared up.

My proposal is to change wording of discussed note to:

Note: result of every standard conversion is never an lvalue, and
therefore all standard conversions (clause 4) are suppressed, when such
direct bindings to lvalues are done.

Rationale (April, 2005):

As acknowledged in the description of the issue, the referenced
text is only a note and has no normative impact. Furthermore, the
examples cited do not involve the conversions mentioned in the note,
and the normative text is already sufficiently clear that the types in
the examples are not reference-compatible.

315.
Is call of static member function through null pointer undefined?

We agreed the example should be allowed. p->f()
is rewritten as (*p).f() according to 5.2.5
[expr.ref].
*p is not an error when p is null unless the
lvalue is converted to an rvalue (4.1
[conv.lval]), which it
isn't here.

359.
Type definition in anonymous union

One compiler faults a type definition (i.e. of the anonymous
struct) since it is in an anonymous union [9.5
[class.union]
paragraph 2:
"The member-specification of an anonymous union shall only define
non-static data members."].

I would suggest that compiler B is correctly interpreting the
standard but that this is a defect in the standard. There is
no reason to disallow definition of anonymous structs.

Furthermore, is it really necessary to disallow definition of
named types in anonymous unions in general, as long as the
types do not need fully qualified names for external linkage?
Why should this be illegal?

There was agreement that the standard says such declarations
are invalid; therefore this must be considered as an extension.
There was general feeling that this extension would not
be too useful, though
Jason Merrill was sympathetic to the argument. It was also
agreed that if this were to be changed it would require careful
wording so as not to allow too many cases.

Note (March, 2008):

The Evolution Working Group recommended closing this issue with no
further consideration. See paper J16/07-0033 = WG21 N2173.

266.
No grammar sentence symbol

Section: A
[gram]
Status: NAD
Submitter: Hans Aberg
Date: 2 Dec 2000

The grammar in Appendix A does not indicate a grammar sentence
symbol and is therefore formally not a grammar.

Rationale (04/01):

Appendix A does not claim to be a formal grammar. The
specification is clear enough in its current formulation.

81.
Null pointers and C compatability

Annex C lists C compatibility issues. One item not in the annex came
up in a discussion in comp.std.c++.

Consider this C and C++ code:

const int j = 0;
char* p = (char*)j;

Rationale (10/99): Because j is not a constant
expression in C, this code fragment has implementation-defined behavior
in C. There is no incompatibility with C resulting from the fact that
C++ defines this behavior.

In addition, there are a number of locations in the Standard where use
of or reference to static should be reconsidered. These
include:

3.2
[basic.def.odr]
paragraph 5,

3.5
[basic.link]
paragraph 6,

3.6.2
[basic.start.init]
paragraph 4,

5.19
[expr.const]
paragraph 2,

7.1
[dcl.spec]
paragraph 2,

7.5
[dcl.link]
paragraph 7, and

8.3.4
[dcl.array]
paragraph 4.

Rationale (04/00):

This issue, along with issue 174, has
been subsumed by issue 223. Until the
committee determines the meaning of deprecation, it does not make
sense either to extend or reduce the number of features to which it is
applied.

174.
Undeprecating global static

We cannot deprecate static because it is an important part of C and to
abandon it would make C++ unnecessarily incompatible with C.

Because templates may be instantiated on members of unnamed namespaces,
some compilation systems may place such symbols in the global linker
space, which could place a significant burden on the linker. Without
static, programmers have no mechanism to avoid the burden.

Rationale (04/00):

This issue, along with issue 167, has
been subsumed by issue 223. Until the
committee determines the meaning of deprecation, it does not make
sense either to extend or reduce the number of features to which it is
applied.

Issues with "Dup" Status

72.
Linkage and storage class specifiers for templates

Section: 14
[temp]
Status: dup
Submitter: Mike Ball
Date: 19 Oct 1998

John Spicer: The standard does say that a namespace scope template
has external linkage unless it is a function template declared "static".
It doesn't explicitly say that the linkage of the template is also the
linkage of the instantiations, but I believe that is the intent.
For example, a storage class is prohibited on an explicit specialization
to ensure that a specialization cannot be given a different storage class
than the template on which it is based.

Mike Ball: This makes sense, but I couldn't find much support
in the document. Sounds like yet another interpretation to add to
the list.

John Spicer: The standard does not talk about the linkage of
instantiations, because only "names" are considered to have linkage, and
instances are not really names. So, from an implementation point
of view, instances have linkage, but from a language point of view, only
the template from which the instances are generated has linkage.

Mike Ball: Which is why I think it would be cleaner to eliminate
storage class specifiers entirely and rely on the unnamed namespace.
There is a statement that specializations go into the namespace of the
template. No big deal, it's not something it says, so we live with
what's there.

John Spicer: That would mean prohibiting static function templates.
I doubt those are common, but I don't really see much motivation for getting
rid of them at this point.

"export" is an additional attribute that is separate from linkage, but
that can only be applied to templates with external linkage.

Mike Ball: I can't find that restriction in the standard, though
there is one that templates in an unnamed namespace can't be exported.
I'm pretty sure that we intended it, though.

John Spicer: I can't find it either. The "inline" case
seems to be addressed, but not static. Surely this is an error as,
by definition, a static template can't be used from elsewhere.

200.
Partial ordering and explicit arguments

The description of how the partial ordering of template functions
is determined in
14.5.6.2
[temp.func.order]
paragraphs 3-5 does
not make any provision for nondeduced template parameters. For
example, the function call in the following code is ambiguous, even
though one template is "obviously" more specialized than the other:

The reason is that neither function parameter list allows template
parameter T to be deduced; both deductions fail, so neither
template is considered more specialized than the other and the
function call is ambiguous.

One possibility of addressing this situation would be to
incorporate explicit template arguments from the call in the argument
deduction using the transformed function parameter lists. In this
case, that would result in finding the first template to be more
specialized than the second.

This example is confusing because the definition of the template function
itself is not ill formed unless it is instantiated with "A" as the template
parameter. In other words, the example should be modified to something
like:

133.
Exception specifications and checking

An exception-specification shall appear only on a function
declarator in a function, pointer, reference or pointer to member
declaration or definition.

This wording forbids
exception specifications in declarations where they might plausibly
occur (e.g., an array of function pointers). This restriction seems
arbitrary. It's also unclear whether this wording allows declarations
such as

At the same time, other cases are allowed by the wording in
paragraph 1 (e.g., a pointer to a pointer to a function), but no
checking for such cases is specified in paragraph 3. For example,
the following appears to be allowed:

82.
Definition of "using" a constant expression

The wording in
3.2
[basic.def.odr]
paragraph 2 about "potentially evaluated" is incomplete. It does not distinguish
between expressions which are used as "integral constant expressions" and
those which are not; nor does it distinguish between uses in which an objects
address is taken and those in which it is not. (A suitable definition
of "address taken" could be written without actually saying "address".)

Currently the definition of "use" has two parts (part (a) and (d) below);
but in practice there are two more kinds of "use" as in (b) and (c):

Use in "sizeof" or a non-polymorphic "typeid". Neither the value
nor the address is really used. No definition is needed at all.

Use as an integral constant expression. Only the value is used. A
static data member with its initializer given in the class need not have
a namespace-scope definition.

Use which requires the value, which is known at compile time because the
object is const, of integral or enum type, and initialized with an integral
constant expression. Only the value need be used, but an implementation
is not required to use the value from the initializer; it might access
the object. So in the original example, the namespace-scope definition
is required even though most compilers will not require it.

All other uses require that the object actually exist because its address
will be taken implicitly or explicitly.

We discussed (b) and decided that the namespace-scope definition was not
needed, but the wording did not make it into the standard.

I don't think we discussed (c).

Rationale (04/99): The substantive part of this issue is
covered by Core issue 48

12.
Default arguments on different declarations for the same function and the Koenig lookup

If the ordinary unqualified lookup of the name finds the declaration
of a class member function, the associated namespaces and classes are not
considered.

to

If the ordinary unqualified lookup of the name finds the declaration
of a class member function or the declaration of a function at block scope,
the associated namespaces and classes are not considered.

Rationale (04/99): The proposal would also apply to local
using-declarations (per Mike Ball) and was therefore deemed
undesirable. The ambiguity issue is
dealt with in Core issue 1

313.
Class with single conversion function to integral as array size in new

Should it be allowed to use an object of a class type having a single
conversion function to an integral type as an array size in the first
bound of the type in an array new?

struct A {
operator int();
} a;
int main () {
new int[a];
}

There are similar accommodations
for the expression in a delete (5.3.5
[expr.delete]
paragraph 1) and in a switch (6.4.2
[stmt.switch]
paragraph 2). There is also widespread existing practice on this
(g++, EDG, MSVC++, and Sun accept it, and even cfront 3.0.2).

548.
qualified-ids in declarations

According to 8.3
[dcl.meaning] paragraph 1, the declarator
in the definition or explicit instantiation of a namespace member can
only be qualified if the definition or explicit instantiation appears
outside the member's namespace:

A declarator-id shall not be qualified except for the
definition of a member function (9.3
[class.mfct]) or static
data member (9.4
[class.static]) outside of its class, the
definition or explicit instantiation of a function or variable member
of a namespace outside of its namespace, or the definition of a
previously declared explicit specialization outside of its namespace,
or the declaration of a friend function that is a member of another
class or namespace (11.4
[class.friend]). When
the declarator-id is qualified, the declaration shall refer to
a previously declared member of the class or namespace to which the
qualifier refers, and the member shall not have been introduced by
a using-declaration in the scope of the class or namespace
nominated by the nested-name-specifier of
the declarator-id.

There is no similar restriction on a qualified-id in a
class definition (9
[class] paragraph 5):

If a class-head contains a nested-name-specifier,
the class-specifier shall refer to a class that was previously
declared directly in the class or namespace to which the
nested-name-specifier refers (i.e., neither inherited nor
introduced by a using-declaration), and
the class-specifier shall appear in a namespace enclosing the
previous declaration.

An elaborated-type-specifier in an explicit instatiation
containing a qualified-id is also not prohibited from appearing
in the namespace nominated by its nested-name-specifier
(14.7.2
[temp.explicit] paragraph 2):

An explicit instantiation shall appear in an enclosing namespace of
its template. If the name declared in the explicit instantiation is an
unqualified name, the explicit instantiation shall appear in the
namespace where its template is declared.

(This asymmetry is due to the removal of inappropriate mention
of classes in 8.3
[dcl.meaning] by
issue 40 and a failure to insert the
intended restrictions elsewhere.)

It is not clear that any purpose is served by the “outside of
its namespace” restriction on declarators in definitions and
explicit instantiations; if possible, it would be desirable to
reconcile the treatment of declarators and class names by removing
the restriction on declarators (which appears to be widespread
implementation practice, anyway).

155.
Brace initializer for scalar

According to 8.5.1
[dcl.init.aggr]
paragraph 2, a brace-enclosed initializer is permitted for a
subaggregate of an aggregate; however, i is a scalar, not an
aggregate. 8.5
[dcl.init]
paragraph 13
says that a standalone declaration like

int i = { 1 };

is permitted, but it is not clear whether this says anything about the
form of initializers for scalar members of aggregates.

This is (more) clearly permitted by the C89 Standard.

Rationale (May, 2008):

Issue 632 refers to exactly the same
question and has a more detailed discussion of the considerations
involved.

Issues with "Extension" Status

623.
Use of pointers to deallocated storage

Any use of a pointer to deleted storage, even if the pointer is not
dereferenced, produces undefined behavior (3.7.3.2
[basic.stc.dynamic.deallocation]
paragraph 4). The reason for this restriction is that, on some historical
architectures, deallocating an object might free a memory segment,
resulting in a hardware exception if a pointer referring to that segment
were loaded into a pointer register, and on those architectures use of a
pointer register for moving and comparing pointers was the most efficient
mechanism for these operations.

It is not clear whether current or foreseeable architectures still
require such a draconian restriction or whether it is feasible to relax
it only to forbid a smaller range of operations. Of particular concern
is the use of atomic pointers, which might be used in race conditions
involving deallocation, where the loser of the race might encounter this
undefined behavior.

The current specification is clear and was well-motivated.
Analysis of whether this restriction is still needed should be done
via a paper and discussed in the Evolution Working Group rather than
being handled by CWG as an issue/defect.

622.
Relational comparisons of arbitrary pointers

The relational operators have unspecified results when comparing
pointers that refer to objects that are not members of the same object
or elements of the same array (5.9
[expr.rel] paragraph 2,
second bullet). This restriction (which dates from C89) stems from
the desire not to penalize implementations on architectures with
segmented memory by forcing them essentially to simulate a flat
address space for the purpose of these comparisons. If such an
implementation requires that objects and arrays to fit within a single
segment, this restriction enables pointer comparison to be done simply
by comparing the offset portion of the pointers, which could
be much faster than comparing the full pointer values.

The problem with this restriction in C++ is that it forces users of
the Standard Library containers to use less<T*> instead
of the built-in < operator to provide a total ordering on
pointers, a usage that is inconvenient and error-prone. Can the
existing restriction be relaxed in some way to allow the built-in
operator to provide a total ordering? (John Spicer pointed out that
the actual comparison for a segmented architecture need only supply a
total ordering of pointer values, not necessarily the complete
linearization of the address space.)

Rationale (April, 2007):

The current specification is clear and was well-motivated.
Analysis of whether this restriction is still needed should be done
via a paper and discussed in the Evolution Working Group rather than
being handled by CWG as an issue/defect.

The whole area of linkage needs revisiting. Declaring calling
convention as a storage class was incorrect to begin
with; it should be a function qualifier, as in:

void f( void (*pf)(int) c_linkage );

instead of the suggested:

void f( extern "C" void (*pf)(int) );

I would like to keep calling convention on the "next round" issues list,
including the alternative of using function qualifiers.

And to that end, I suggest that the use of linkage specifiers to specify
calling convention be deprecated - which would make any use of linkage
specifiers in a parameter declaration deprecated.

Martin Sebor:
7.5
[dcl.link], paragraph 4 says that "A
linkage-specification shall occur only in namespace scope..." I'm
wondering why this restriction is necessary since it prevents, among
other things, the use of the functions defined <cmath>
in generic code that involves function objects. For example, the
program below is ill-formed since
std::pointer_to_binary_function<> takes a pointer to a
function with extern "C++" linkage which is incompatible with the type
of the double overload of std::pow.

Relaxing the restriction to allow linkage specification in
declarations of typedefs in class scope would allow
std::pointer_to_binary_function<> ctor to be overloaded
on both types (i.e., extern "C" and extern "C++"). An alternative
would be to allow for the linkage specification to be deduced along
with the type.