Re: Extern "C" block and its effect on const variable linkage
Motti Lanzkron schrieb:
I know that variables implicitly have external linkage unless they are
declared const. I've run into unexpected (for me) behaviour when a
const variable is declared inside an extern "C" block, the variable
gets internal linkage rather than external as I expected.
I can't find the standard saying that there is any difference between:
extern "C" declaration
extern "C" { declaration sequence }
There are differences, but some are more well and some are less
well expressed ;-). Probably due to some fuzzinesses the draft
wording
(currently: N2134) has been changed somewhat.
Taking the currently valid 14882-2003 as reference a "clear"
difference
is expressed in 7.5/4:
"In a linkage-specification, the specified language linkage applies to
the
function types of all function declarators, function names, and
variable
names introduced by the declaration(s)."
The new wording is now (emphasis mine):
"In a linkage-specification, the specified language linkage applies to
the
function types of all function declarators, function names with
*external*
linkage, and variable names with *external* linkage declared within
the
linkage-specification."
one of the examples point that out:
"extern "C" {
static void f4(); // the name of the function f4 has
// internal linkage (not C language
// linkage) and the function's type
// has C language linkage.
}"
Para 7 of 14882-2003 points out the difference between the braced and
unbraced forms:
"Except for functions with internal linkage, a function first declared
in a
linkage-specification behaves as a function with external linkage.[..]
The form of linkage-specification that contains a brace-enclosed
declaration-seq does not affect whether the contained declarations
are
definitions or not (3.1); the form of linkagespecification directly
containing
a single declaration is treated as an extern specifier (7.1.1) for
the
purpose of determining whether the contained declaration is a
definition.
[..]A linkage-specification directly containing a single declaration
shall
not specify a storage class. [Example: extern "C" static void f(); //
error
-end example]"
Unfortunately this wording can be interpreted (at least in the
beginning)
that the differences are restricted to function linkage. But the
further
words don't restrict on functions and I interpret it to mean that the
unbraced form restricts the linkage to external (and thus conflicting
linkage specifications are not allowed). Inside the braced form the
"normal" linkage rules apply.
This is also better expressed in the current draft:
Para 7:
"A declaration directly contained in a linkage-specification is
treated as
if it contains the extern specifier (7.1.1) for the purpose of
determining the
linkage of the declared name and whether it is a definition. Such a
declaration shall not specify a storage class. [ Example:
extern "C" double f();
static double f(); // error
extern "C" int i; // declaration
extern "C" {
int i; // definition
}
extern "C" static void g(); // error"
// check if variable has internal linkage (complication error
otherwise)
template<const int& T> void f() {}
int i = 0; // implicit external
const int ci = 1; // implicit internal
extern const int eci = 2; // explicitly external
extern "C" const int eCci = 3; // still explicitly external
extern "C" {
const int eCbci= 4; // I thought external but I seem to be
wrong
}
int main()
{
f<i>(); // OK
f<ci>(); // Error
f<eci>(); // OK
f<eCci>(); // OK
f<eCbci>(); // Error, shouldn't this be OK?
}
IMO this compiler behaves conforming.
Greetings from Bremen,
Daniel Kr|gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]