为了澄清，此答案的信息不正确（托马斯在评论后将其答案固定，很酷:)）。其他答案只是避免解释静态分配的含义。因此，我将在下面解释三种主要的分配形式，以及它们通常与堆，堆栈和数据段的关系。我还将在C / C ++和Python中显示一些示例，以帮助人们理解。
“静态”（又名静态分配）变量未分配在堆栈上。不要这么假设-许多人这样做只是因为“静态”听起来很像“堆栈”。它们实际上既不存在于堆栈中，也不存在于堆中。是所谓的数据段的一部分。
但是，通常最好考虑“ 作用域 ”和“ 生存期 ”，而不是“堆栈”和“堆”。
范围是指代码的哪些部分可以访问变量。通常，我们认为本地范围（只能由当前函数访问）与全局范围（可以在任何地方访问）相比，尽管范围会变得更加复杂。
生存期是指在程序执行期间何时分配和释放变量。通常，我们认为静态分配（变量将在程序的整个过程中持续存在，从而使它在多个函数调用之间存储相同的信息很有用）与自动分配（变量仅在单个调用函数中持续存在，从而使其对存储仅在函数运行期间使用的信息，完成后可以将其丢弃）与动态分配（持续时间在运行时定义的变量，而不是静态或自动的编译时）相比。
尽管大多数编译器和解释器在使用堆栈，堆等方面都类似地实现了此行为，但是只要行为正确，编译器有时可能会破坏这些约定。例如，由于优化，即使大多数局部变量存在于堆栈中，局部变量也可能仅存在于寄存器中或被完全删除。正如一些评论中指出的那样，您可以自由地实现甚至不使用堆栈或堆，而是使用其他一些存储机制的编译器（很少使用，因为堆栈和堆对此非常有用）。
我将提供一些简单的带注释的C代码来说明所有这些。最好的学习方法是在调试器下运行程序并观察行为。如果您喜欢阅读python，请跳到答案的结尾:)
// Statically allocated in the data segment when the program/DLL is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in the code
int someGlobalVariable;
// Statically allocated in the data segment when the program is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in this particular code file
static int someStaticVariable;
// "someArgument" is allocated on the stack each time MyFunction is called
// "someArgument" is deallocated when MyFunction returns
// scope - can be accessed only within MyFunction()
void MyFunction(int someArgument) {
// Statically allocated in the data segment when the program is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed only within MyFunction()
static int someLocalStaticVariable;
// Allocated on the stack each time MyFunction is called
// Deallocated when MyFunction returns
// scope - can be accessed only within MyFunction()
int someLocalVariable;
// A *pointer* is allocated on the stack each time MyFunction is called
// This pointer is deallocated when MyFunction returns
// scope - the pointer can be accessed only within MyFunction()
int* someDynamicVariable;
// This line causes space for an integer to be allocated in the heap
// when this line is executed. Note this is not at the beginning of
// the call to MyFunction(), like the automatic variables
// scope - only code within MyFunction() can access this space
// *through this particular variable*.
// However, if you pass the address somewhere else, that code
// can access it too
someDynamicVariable = new int;
// This line deallocates the space for the integer in the heap.
// If we did not write it, the memory would be "leaked".
// Note a fundamental difference between the stack and heap
// the heap must be managed. The stack is managed for us.
delete someDynamicVariable;
// In other cases, instead of deallocating this heap space you
// might store the address somewhere more permanent to use later.
// Some languages even take care of deallocation for you... but
// always it needs to be taken care of at runtime by some mechanism.
// When the function returns, someArgument, someLocalVariable
// and the pointer someDynamicVariable are deallocated.
// The space pointed to by someDynamicVariable was already
// deallocated prior to returning.
return;
}
// Note that someGlobalVariable, someStaticVariable and
// someLocalStaticVariable continue to exist, and are not
// deallocated until the program exits.
为什么区分生命周期和作用域很重要的一个特别令人毛骨悚然的示例是变量可以具有局部作用域，但具有静态生命周期-例如，上面的代码示例中的“ someLocalStaticVariable”。这样的变量会使我们常见但非正式的命名习惯非常混乱。例如，当我们说“ 本地 ”时，我们通常是指“ 本地范围内的自动分配的变量 ”，而当我们说“ 全局 ”时，我们通常是指“ 全局范围的静态分配的变量 ”。不幸的是，当涉及到“ 文件范围内的静态分配的变量 ”之类的事情时，许多人只是说...“ 呵呵 ”。
C / C ++中的某些语法选择加剧了这个问题-例如，由于以下所示的语法，许多人认为全局变量不是“静态”的。
int var1; // Has global scope and static allocation
static int var2; // Has file scope and static allocation
int main() {return 0;}
请注意，在上面的声明中添加关键字“ static”可防止var2具有全局作用域。但是，全局var1具有静态分配。这不直观！因此，在描述范围时，我尽量不要使用“静态”一词，而应使用诸如“文件”或“文件受限”范围之类的名称。但是，许多人使用短语“静态”或“静态作用域”来描述只能从一个代码文件访问的变量。在生命周期的上下文中，“静态” 始终表示变量在程序启动时分配，并在程序退出时释放。
有些人认为这些概念是C / C ++特有的。他们不是。例如，下面的Python示例说明了所有三种分配类型（在解释性语言中可能存在一些细微的差异，我将不在这里介绍）。
from datetime import datetime
class Animal:
_FavoriteFood = 'Undefined' # _FavoriteFood is statically allocated
def PetAnimal(self):
curTime = datetime.time(datetime.now()) # curTime is automatically allocatedion
print("Thank you for petting me. But it's " + str(curTime) + ", you should feed me. My favorite food is " + self._FavoriteFood)
class Cat(Animal):
_FavoriteFood = 'tuna' # Note since we override, Cat class has its own statically allocated _FavoriteFood variable, different from Animal's
class Dog(Animal):
_FavoriteFood = 'steak' # Likewise, the Dog class gets its own static variable. Important to note - this one static variable is shared among all instances of Dog, hence it is not dynamic!
if __name__ == "__main__":
whiskers = Cat() # Dynamically allocated
fido = Dog() # Dynamically allocated
rinTinTin = Dog() # Dynamically allocated
whiskers.PetAnimal()
fido.PetAnimal()
rinTinTin.PetAnimal()
Dog._FavoriteFood = 'milkbones'
whiskers.PetAnimal()
fido.PetAnimal()
rinTinTin.PetAnimal()
# Output is:
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is milkbones
# Thank you for petting me. But it's 13:05:02.256000, you should feed me. My favorite food is milkbones
