区分静态变量、动态变量、内部变量（局部变量）、外部变量（全局变量）
 
静态变量、动态变量、内部变量（局部变量）、外部变量（全局变量）
变量的分类来看
 

 
静态变量、动态变量、内部变量（局部变量）、外部变量（全局变量）
 
文章参考：https://blog.csdn.net/21aspnet/article/details/2560072
 文章参考：https://blog.csdn.net/u013921430/article/details/79279114
 
变量的分类来看
 
变量分类
 
作用域分类
 局部变量（默认是自动局部变量）
 1. 定义：在一个函数内部定义的变量（包括函数形参）
 2. 有效范围：一直在本函数有效
 3. 变量存储：栈内存，函数结束之后自动销毁
 4. 静态局部变量：存储在静态存储区，作用域依旧在函数体内部。每次对其修改都会被保存下来。
 ** 全局变量 **
 1. 定义：在函数外部定义的变量，可为本源文件中其他函数使用
 2. 有效范围：从定义变量的位置开始到本源文件的结束
 3. 变量存储：存储在静态存储区域（静态内存）
 4. 可被工程项目其他文件的 extern 声明之后调用，对其每次修改都会进行保存
 5. 静态全局变量：不能被其他源文件使用，只能本源文件使用，并且每次修改会被保存
生存周期分类
 静态存储方式——程序运行期间分配固定的存储空间的方式
 动态存储方式——程序运行期间根据需要进行的动态分配空间的方式
 又可分为
 1. auto（自动）——默认，数据存储在动态存储
 2. static（静态）——函数在调用结束之后会保存本次调用的数值
 3. register（寄存器）——在声明动态局部变量或者函数形参时，可将变量声明为register，这样编译系统就会为变量分配一个寄存器而不是内存空间，通过这种方式可提升对某些局部变量频繁调用的程序的性能。（寄存器运算速度远高于内存）
 4. extern （外部）——扩展全局变量的作用域

0.静态存储与动态存储
 
1）静态存储变量通常是在变量定义时就分定存储单元并一直保持不变，直至整个程序结束。静态变量，全局动态变量都是静态存储
 
2）动态存储变量是在程序执行过程中，使用它时才分配存储单元，使用完毕立即释放
 
3）静态存储变量是一直存在的，而动态存储变量则时而存在时而消失。通常把由于变量存储方式不同而产生的特性称为变量的生存期
 
4）静态存储只会初始化一次
 
 
 
摘自于：百度百科
 
 
 
1.区别
 
定义或者声明变量时，没有static修饰符的就是动态变量，有static修饰符的就是静态变量
 
 
 
2.动态变量（一下简称变量）
 
2.1全局变量
 
1）在所有函数的外部定义（包括主函数），定义之后的所有函数都能使用，属于静态存储
 
2）作用域为整个项目，即最终编译成可执行文件的所有文件中均可以使用动态全局变量。外部文件可以通过extern关键字来声明另一个文件中存在的全局变量
 
3）生命周期为从程序运行到程序退出，即贯穿整个运行时间
 
4）无显式初始化时默认初始化值为0
 
看一个有关全局变量多文件的例子：
 
main.cpp
 
#include <iostream>
using namespace std;

int var_a = 0;

void fun1();
void fun2();

void fun0()
{
	var_a = var_a + 1;
	cout << "fun1:" << var_a << endl;
}


int main()
{
	fun0();
	fun1();
	fun2();
	fun0();

	system("pause");
	return 0;
}
 
variable1.cpp
 
#include <iostream>
using namespace std;

extern int var_a;

void fun1()
{
	var_a = var_a + 1;
	cout << "fun3:" << var_a << endl;
}
 
variable2.cpp
 
#include <iostream>
using namespace std;

extern int var_a;

void fun2()
{
	var_a = var_a + 1;
	cout << "fun3:" << var_a << endl;
}
 
运行结果：
 
 
可以发现，全局变量var_a在所有文件中都共享，每个文件都可以访问它并修改它的值
 
2.2局部变量
 
1）在函数内部定义，属于动态存储，其他函数不能访问，外部文件也不能访问，否则会出现：
 
 
2）作用域为当前函数，从定义位置，到其所在的{}的结束位置
 
3）生命周期为从函数调用到函数退出
 
4）无显式初始化时默认初始化值为随机值
 
 
 
3.静态变量
 
3.1静态全局变量
 
1）作用域为当前文件，从定义/声明位置到文件结尾
 
2）生命周期为从程序运行到程序退出，即贯穿整个运行时间
 
3）无显式初始化时默认初始化值为0
 
静态全局变量与动态全局变量的主要不同：
 
动态全局变量可以通过extern关键字在外部文件中使用，但静态全局变量不可以在外部文件中使用。静态全局变量相当于限制了动态全局变量的作用域
 
看一个例子：
 
#include <iostream>
using namespace std;

static int b = 10;

void fun()
{
	int b = 0;
	cout << "b = " << b << endl;
	b++;
}

int main()
{
	for (int i = 0; i < 5; i++)
		fun();

	system("pause");
	return 0;
}
 
得到结果：
 
 
为什么得到5个0呢，为什么不是0，1，2，3，4呢
 
这是因为在函数fun中定义了一个动态局部变量a，而a同时又是静态全局变量，在这种情况下，作用域小的掩盖作用域大的，所以局部变量会掩盖全局变量。所以动态局部变量a掩盖了静态全局变量a
 
3.2静态局部变量
 
1）作用域为当前函数，从定义位置，到其所在的{}的结束位置
 
2）生命周期为从程序运行到程序退出，即贯穿整个运行时间，当下次函数调用时，静态局部变量不会被再次初始化，而是沿用上次函数退出时的值
 
静态局部变量与动态局部变量的主要不同：
 
两者作用域相同，都在函数内部，但是两者生命周期不一样，静态局部变量的生命周期是到程序的结束，而动态局部变量的生命周期是函数的结束，静态局部变量的生命周期更长，同时静态局部变量只会初始化一次，函数重复调用，但静态局部变量不会被重新初始化
 
看一段代码：
 
#include <iostream>
using namespace std;

void fun()
{
	int a = 0;
	static int b = 0;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	a++;
	b++;
}

int main()
{
	for (int i = 0; i < 5; i++)
		fun();

	system("pause");
	return 0;
}
 
执行结果：
 
 
得到这样的结果也是自然的
 
参考来源：
 
C语言动态变量与静态变量的区别
 
C和C++中全局变量，局部变量，静态变量和常量

1. 什么是动态变量？
 
i=1
x&i=3
 
x&i就是动态变量。
 
如果x&i按照我们所想的一样，那么上述程序的结果应该是得到了一个变量x1=3
 
上述程序在VBA中可直接实现。
 
动态变量可以用于批量变量迭代，这是动态变量最重要的意义。如：
 
for(i in 1:100）{
x&i=i
}
 
这是时候我们快速地生成了x1：x100这100个变量，并进行了赋值。如果x&i的作用按照我们想的一样实现了的话，那么上述程序应该生成了x1=1,x2=x,x3=3...x100=100
 
所以问题的核心就是x&i的实现，核心的核心就是&的含义。
 
在SAS中，我记得连接需要加一个英文句号：
 
x&.i=3
 
在VBA中，可直接用
 
x&i=3
 
然而在R与Python要复杂得多。
 
2. Python动态变量(dynamic variable)
 
有一篇写的很好的博客，参见Python动态变量名定义与调用
 
字典方法
 
字典方法是Stack Overflow社区最推崇的方法，但是它不能适用于对复杂变量进行进一步的操作。它不能解决字典的value对变量名的引用。
 
d={}
for i in range(5):
    d['x'+str(i)]=i
 
 
那么现在我们把问题复杂化一点，假设我已经有了x1-x4这么几个变量，他们都是列表。我想只留下非0的值，那么理想的伪代码如下：
 
x1=np.array([1,2,3,0])
x2=np.array([5,6,0,8])
x3=np.array([3,5,0,0])
x4=np.array([3,45,2,1])
for i in range(1,5):
    xi=xi[xi!=0]
 
那么字典方法应该怎么做呢？首先应该将变量全部写到字典里面去，，，然后发现首先这一步就没法做，它不能解决字典的value对变量名的引用，就是在值里面无法引用动态变量。
 
你打算这么做吗？
 
d['x'+str(i)]='x'+str(i)
 
 可是右边只返回了一个字符串，不指代xi。
 
命名空间法
 
Python中有三个函数是变量字典：locals(),globals, vars()。
 
他们之间的区别参见：What's the difference between globals(), locals(), and vars()?
 
一般使用locals,他会返回当前存在的变量，返回格式是一个字典。也就是说，如果我们先定义x1=2，那么在locals字典中就已经记录了下来，使用
 
loacals()['x1']
 
就可以引用变量x1了，这就是一个普通字典格式，dict['key']=value。
 
好我们继续上面的问题，现在就可以很方便地解决了
 
x1=np.array([1,2,3,0])
x2=np.array([5,6,0,8])
x3=np.array([3,5,0,0])
x4=np.array([3,45,2,1])
for i in range(1,5):
    locals()['x'+str(i)]=locals()['x'+str(i)][locals()['x'+str(i)]!=0]
 
 
 
print(x1,x2,x3,x4)

[1 2 3] [5 6 8] [3 5] [ 3 45  2  1]
 
 exec
 
在Python中同样有三个函数可以编译执行字符串语句：exec，eval，compile，详细地讲解参见
 
python中的exec()、eval()以及complie()
 
What's the difference between eval, exec, and compile?
 
exec，动态执行python代码，返回值永远为None，能够同时解析字符串和python语句，这使得exec能够用于动态变量生成
eval，只支持单个表达式，不支持赋值，返回单个表达式执行的结果。
eval('1+2')#返回3
exec('1+2')#无返回值
 
 exec可同时解析字符串和python语句，但exec的输入必须全是字符串格式。下面的语句定义了x1=2：
 
exec('x'+str(1)+'='+str(2))#全是字符串，以+连接
 
虽然stack overflow上面最推崇字典法，而认为命名空间法不是一个很好的办法，因为他改变了全局变量，比如如果你之前有某个变量定义为x23，你在动态变量里面改变了x23的赋值，你可能没有注意到这一点，这可能会造成意料之外的错误。但是我认为，命名空间法非常的便捷，并且很多复杂的数据结构的时候，命名空间法师唯一可行的方法。
 
3. R中动态变量的引用
 
我最爱的R在这里确实最复杂的，&在R中是逻辑运算“和”，并不表示连接。
 
一般有五种方法能够实现变量批量命名：
 
对list使用setName
my_power_list=setNames( as.list( 1:5), paste0("x", 1:5) )
 
效果是这样的：
 
 
这实际上用了一个列名重命名技术而已。而且只在列表中，效果很有限。
 
list2env转换全局变量
x =as.list(rnorm(100))
names(x) = paste("a", 1:100, sep = "")#列表重命名
list2env(x , envir = .GlobalEnv)#将列表变量转换为全局变量
 
 
eval(paste)解析法
vals <- rnorm(3)
n    <- length(vals)
lhs  <- paste("a",    1:n,     sep="")
rhs  <- paste("vals[",1:n,"]", sep="")
eq   <- paste(paste(lhs, rhs, sep="<-"), collapse=";")
eval(parse(text=eq))
 
其本质是生成了一段文本，然后用parse去解析，在用eval进行符号运算。
 
上面的三种并不是很常用，我比较喜欢下面两种：
 
assign(paste)
assign(paste0("x", 1:100), 1:100)
 
这一次性生成了100个变量：xi=i。
 
上面已经讲到，动态变量最重要的意义是能够利用迭代对变量进行批量运算。很遗憾，仅仅凭借上面的函数是无法实现迭代的。我们需要另外一个函数：get（）。get函数和assign是一对，assign给字符赋值，get获得字符的值。
 
现在看一个实例。假定有一个数据集d是100行30列的，也就是说有30个变量，现在用bootstrap收集它的系数。进行100次随机抽样，每一次抽样用第一列数据对其他列进行线性回归，这样，每一次回归都会得到一次beta0~beta29，一共30个beta（还有个截距项beta0）。进行100次抽样后再回归就得到了100个不同的beta0，把这些beta0全部追加到变量beta0中。然后进行统计量的估计。也就是说，最后我们的结果是：。
 
d=matrix(rnorm(100*30),100,30)
d=data.frame(d)
cs=paste0('beta',1:30)
for(k in 1:30){
  assign(cs[k],c())
}#要追加必给初值
for(j in 1:100){
  i=sample(1:100,80,replace = F)
  d1=d[i,]
  model=lm(X1~.,data=d1)
  for(k in 1:30){
    assign(cs[k],c(get(cs[k]),coef(model)[k]))
  }
}
 
 
如果不进行动态变量引用，那么我们程序可能是这样滴：
 
d=matrix(rnorm(100*30),100,30)
d=data.frame(d)
beta0=c()
beta1=c()
beta2=c()
beta3=c()
beta4=c()
beta5=c()
beta6=c()
beta7=c()
...
beta30=c()
for(j in 1:100){
  i=sample(1:100,80,replace = F)
  d1=d[i,]
  model=lm(X1~.,data=d1)
  beta0=c(beta0,coef(model)[1])
  beta1=c(beta1,coef(model)[2])
  beta2=c(beta2,coef(model)[3])
  beta3=c(beta3,coef(model)[4])
  beta4=c(beta4,coef(model)[5])
  beta5=c(beta5,coef(model)[6])
  beta6=c(beta6,coef(model)[7])
  beta7=c(beta7,coef(model)[8])
  ...
  beta30=...
}
 
现在你知道了动态引用的重要意义了吧，没错，几十倍地精简代码！对变量进行批量迭代！
 
再看最后一种方法。
 
globalen进行动态引用
这种方法其实是最符合x&i定义的一种方法。
 
e=globalenv()
name=paste0('x',1:5)
e[[name[1]]]=3
 
似乎有点像Python的locals，但是注意：
 
必须使用一个变量指代globalen(),即，而Python中可以直接使用locals()
必须有一个变量，里面包含了要全局化的变量名，这和assign（paste）也一样，也需要有全部的变量名
e后面必须是双括号
使用这种方法进行bootstrap：
 
e=globalenv()
cs=paste0('beta',1:30)
for(k in 1:30){
  assign(cs[k],c())
}

for(j in 1:100){
  i=sample(1:100,80,replace = F)
  d1=d[i,]
  model=lm(X1~.,data=d1)
  for(k in 1:30){
    e[[cs[k]]]=c(e[[cs[k]]],coef(model)[k])
  }
}
 
 

shell 中的动态变量名
 
avr_0=
avr_1=
avr_2=
avr_3=
avr_4=
avr_5=
avr_6=
avr_7=

# 赋值 avr_x = 
for i in $(seq 0 7)
do
eval avr_${i}=${i}
done

# 取值
for i in $(seq 0 7)
do
tmp=$(eval echo '$'avr_${i})
eval echo ${tmp}
done