什么情况下可以在定义中使用extern变量？
我非常非常抱歉。我不知道我不完整的代码附件会造成如此混乱。很高兴看到这么多真诚的帮助。
此代码将编译：
int myadd(int, int);
static int main_stat = 5;
int main()
{
int i, j;
main_stat = 13;
j = myadd(-1,7);
i = main_stat;
cout << j << i; // 3 and 13
return 0;
}
myadd.cpp
extern int main_stat = -3;
int myadd(int x,int y)
{
int t = main_stat;
t = x + y;
y = t +main_stat;
return y; // will return 3
}
请参阅我定义的外部链接 main_stat。为什么这是合法的？我以为你只能链接而不能定义。
myadd 函数调用的堆栈帧中是否分配了存储空间？全局静态分配在堆上，我相信，对吧？
编辑
我很抱歉，但我想这次我会缩小我的问题范围：
来自 C++ Primer 4ed
extern 声明可以包含初始化程序（当组合时 仅当它出现在函数外部时才成为定义。
我很清楚单一定义规则。
Q1. myadd(int,int) 被调用时使用 main_stat 的哪个副本？与主副本相同，但具有不同的值（我可以测试）？或者每个函数都有自己的静态全局副本？
Q2。堆上是否为这些全局静态变量分配了内存？我知道很多事情都需要实现，但是堆不是用于静态变量吗？
Q3。我知道以下两个是有效的，
extern int x; // means int x is defined elsewhere
extern int x = 3; // declared and defined
如果我们可以在 myadd 的命名空间中声明一个静态全局变量，为什么我们需要第二个？它如何像 aschepler 所说的那样让事情变得清晰？
I am very very sorry. I didn't know my incomplete code attachment would create such a mess. I am very glad to see so many sincere helps.
This code will compile:
int myadd(int, int);
static int main_stat = 5;
int main()
{
int i, j;
main_stat = 13;
j = myadd(-1,7);
i = main_stat;
cout << j << i; // 3 and 13
return 0;
}
myadd.cpp
extern int main_stat = -3;
int myadd(int x,int y)
{
int t = main_stat;
t = x + y;
y = t +main_stat;
return y; // will return 3
}
See I defined and extern linking main_stat. Why is that legal? I thought you could only link and not define.
Is storage allocated in the stack frame of myadd function call? Global static are allocated on heap, I believe, right?
EDIT
I am sorry, but I think this time I will narrow down my questions:
From C++ Primer 4ed
An extern declaration may include an initializer (when combined
becomes definition) only if it appears outside a function.
I am clear about one-definition rule.
Q1. Which copy of main_stat does myadd(int,int) uses when it is called? The same copy as the main has, but with a different value (which I can test) ? Or does each function has its own static global copy?
Q2. Is memory allocated on the heap for these global static variables? I know many things are up to implementation, but isn't heap used for static variables?
Q3. I know the followings two are valid
extern int x; // means int x is defined elsewhere
extern int x = 3; // declared and defined
Why do we want the second one if we can just declare a static global variable within the namespace of myadd ? How does it make things clear like aschepler said?
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（6）
所有带有初始值设定项的变量声明也是定义；
这是一条压倒一切的规则。无论
extern如何。甚至还有在定义上需要
extern的情况：您只能使用具有外部链接的变量实例化模板。和
const变量默认具有内部链接，因此您需要例如：
如果您想使用它来实例化
template。All variable declarations with an initializer are also definitions;
that's an overriding rule. Regardless of
extern. There are evencases where you need an
externon a definition: you can onlyinstantiate a template using a variable which has external linkage. And
constvariables have internal linkage by default, so you needsomething like:
if you want to use it to instantiate a
template<int const*>.以下是声明和定义：
添加
extern表示“请仅将其设为声明”。但是当您提供一个值时，该行必须是一个定义，因此该变量获得
extern存储类，并且您恰好在适当的位置定义了它：链接语义与
extern的通常情况相同，存储位置与正常定义int x = 3一样 — 即在命名空间的 TU 中范围。myadd根本不相关。这是一个很难“证明”的问题，因为这是一个“没有规则反对它”的案例。
这是最好的引用：
以及其他一些相关信息：
The following is a declaration and definition:
Adding
externsays "make it a declaration only, please".But when you are providing a value, the line has to be a definition, so the variable gets
externstorage class and you just happen to be defining it right in place anyway:The linkage semantics are as they usually are for
extern, and the storage location is just as it would be for a normal definitionint x = 3— i.e. in that TU at namespace scope.myaddis not relevant at all.It's a hard one to "prove", because it's a case of "there's no rule against it".
Here's the best quote:
And some other pertinent information:
声明并定义
main_stat，While：仅声明变量
main_stat。您可以拥有任意数量的声明，但只能拥有一个定义。
关键字
extern表示外部链接。如果没有它，main_stat将是静态的并具有内部链接，并且您不能使用另一个翻译单元的main_stat。不，绝对不在
add的堆栈框架上。内存分配的位置是实现定义的，但您可以保证该对象在整个程序持续时间内都处于活动状态。
declares and defines
main_stat, While:just declares the variable
main_stat.You can have as many declarations as you want but you can have only one Definition.
The keyword
extern, indicates External Linkage. Without itmain_statwould be static and have Internal linkage and you cannot not usemain_statfrom another translation unit.No definitely not on the stackframe of
add.Where the memory is allocated is implementation defined but you have the assurance that the object will be alive throughout the duration of the program.
这个问题显然源于一些误解。
有些人认为
extern关键字总是将定义变成非定义声明。这根本不是真的。关键字
extern只是给出声明的实体外部链接。它可以应用于声明。它可以应用于定义（请记住，定义也是声明）。因此，说无法定义
extern实体是绝对不正确的。一个可以。这完全没有问题。造成混乱的原因通常是，当您将 extern 应用于类似定义时，
该定义突然变成了非定义声明。这是事实，但这只不过是必须记住的
extern关键字的一次性怪癖。如果您采用类似的定义，那么对其应用
extern关键字仍会将其保留为定义，即在这种情况下没有怪癖。The question apparently stems from some misconception.
Some people believe that
externkeyword always turns a definition into a non-defining declaration. This is simply not true.The keyword
externsimply gives the declared entity external linkage. It can be applied to declarations. It can be applied to definitions (and remember that definitions are declarations as well).So, saying that one can't define an
externentity is absolutely incorrect. One can. There's no problem with that at all.The confusion is usually caused by the fact that when you apply
externto a definition likethat definition suddenly turns into a non-defining declaration. This is true, but this is is no more than a one-off quirk of
externkeyword that has to be remembered. If you take a definition likethen applying the
externkeyword to it will still preserve it as a definition, i.e. no quirks in this case.首先，根据您的评论，包含 main 函数的文件具有定义
static int main_stat = 10;。您应该知道，这与您在包含myadd的文件中定义的变量不同，因为作为静态变量，其范围仅限于该文件。事实上，由于具有相同名称的静态变量，main无法访问您在此文件中定义的变量。但这并不意味着这两个变量都是在堆栈上创建的。两者都是单独的全局变量，只是包含
main的文件中的变量main_stat（我简称该文件为 main 文件，这个 myadd 文件）是在任何其他文件中不可用，而您在此处定义的变量main_stat可以从包含声明extern main_stat;的任何文件访问（注意：没有初始化程序！）。但是，主文件不能包含此声明，因为它会与同名的静态变量冲突。请注意，给出初始值设定项会使变量声明成为定义，也就是说，它与省略 extern 相同（但请注意，如果将变量声明为常量，则不能省略 extern，因为常量默认为静态）。唯一不是定义的全局 extern 声明是那些带有 extern，但不带有初始化器的声明。
First, according to your comment, the file containing the main function has the definition
static int main_stat = 10;. You should be aware that this isnotthe same variable as you defined in the file containingmyaddbecause as static variable its scope is restricted to that file. Indeed, thanks to that static variable with the same name,mainis not able to access the variable you defined in this file.But that doesn't mean that either variable was created on the stack. Both are separate global variables, it's just that the variable
main_statin the file containingmain(I'll call that file main file for short, and this one myadd file) is not available in any other file, while the variablemain_statyou defined here can be accessed from any file which contains the declarationextern main_stat;(note: without initializer!). The main file cannot contain this declaration, however, because it would conflict with the static variable of the same name.Note that giving an initializer makes your declaration of the variable a definition, that is, it's the same as if you had omitted the extern (note however that if a variable is declared constant, the extern may not be omitted because constants are by default static). The only global extern declarations which are not also definitions are those with extern, but without initializer.
其他人都很好地介绍了这一点，但只是为了在一个地方显示变体：
是声明和定义。
x的初始值为零。是一个声明和定义。
在 C++ 中是非法的。
是一个声明和定义，但是如果这是翻译单元中的第一个声明，则
cx具有内部链接。是一个声明，但不是一个定义。程序中的其他地方必须有
x的定义。是一个声明和一个定义。
extern是不必要的，但它使事情变得清晰。是一个声明，但不是一个定义。程序中的其他地方必须有
cx的定义。是一个声明和一个定义。除非已经看到上面的先前声明，否则需要
extern。Everyone else has covered this pretty well, but just to show the variants in one place:
is a declaration and definition. The initial value of
xis zero.is a declaration and definition.
is illegal in C++.
is a declaration and definition, but
cxhas internal linkage if this is its first declaration in the translation unit.is a declaration but NOT a definition. There must be a definition of
xsomewhere else in the program.is a declaration and a definition. The
externis unnecessary, but makes things clear.is a declaration but NOT a definition. There must be a definition of
cxsomewhere else in the program.is a declaration and a definition. The
externis needed unless the previous declaration above was already seen.