有人可以解释static和const变量之间的区别吗？
常数值不能改变。静态变量存在于函数或类中，而不是实例或对象。
这两个概念并不相互排斥，可以一起使用。
const表示常量，它们的值在编译时定义，而不是在运行时显式更改它，在运行时期间不能更改常量的值
但是，静态变量是可以在运行时初始化和更改的变量。但是，静态变量与变量的不同之处在于静态变量保留了整个程序的值，即它们的生命周期是程序，或者直到程序通过动态分配方法分配内存。但是，即使它们在程序的整个生命周期中都保留了它们的值，但它们在它们所在的代码块之外是不可访问的
有关静态变量的更多信息，请参阅here
常量变量无法更改。静态变量是文件专用的，只能在程序代码中访问，而不能访问其他任何人。
static关键字定义变量的范围，而const关键字定义在程序执行期间无法更改的变量的值
简单而简短的回答是内存只为static和const分配一次。但是在const中只有一个值，其中静态值可能会改变，但内存区域在程序结束前保持不变。
Const意味着“无法改变”。
静态意味着“静态实例（在内存中）与动态实例（在堆栈上）。”在程序的持续时间内存在静态变量。根据需要创建和销毁动态的动态。
变量可以是一个或两个。
静态的
用于使变量成为类变量。声明时无需定义静态变量。
例：
#include <iostream>
class dummy
{
public:
static int dum;
};
int dummy::dum = 0; //This is important for static variable, otherwise you'd get a linking error
int main()
{
dummy d;
d.dum = 1;
std::cout<<"Printing dum from object: "<<d.dum<<std::endl;
std::cout<<"Printing dum from class: "<<dummy::dum<<std::endl;
return 0;
}
这将打印：从对象打印dum：1从类打印dum：1
变量dum是一个类变量。尝试通过对象访问它只是通知编译器它是哪个类的变量。考虑一种情况，您可以使用变量来计算创建的对象数。静态会在那里派上用场。
常量
用于使其成为只读变量。您需要立即定义和声明const变量。
在上面提到的同一个程序中，让dum成为一个const：
class dummy
{
public:
static const int dum; // This would give an error. You need to define it as well
static const int dum = 1; //this is correct
const int dum = 1; //Correct. Just not making it a class variable
};
假设在主要方面，我这样做：
int main()
{
dummy d;
d.dum = 1; //Illegal!
std::cout<<"Printing dum from object: "<<d.dum<<std::endl;
std::cout<<"Printing dum from class: "<<dummy::dum<<std::endl;
return 0;
}
尽管静态已经易于理解，但const在c ++中搞砸了。以下资源有助于更好地理解它：http://duramecho.com/ComputerInformation/WhyHowCppConst.html
静态值可以存在于函数中，可以以不同的形式使用，并且可以在程序中具有不同的值。此外，在递减递减后的程序期间，它们的值可能会改变，但在整个程序期间常量不变。
简短的回答：
const是一个承诺，你不会尝试修改一旦设置的值。
static变量意味着对象的生命周期是程序的整个执行，并且它的值仅在程序启动之前初始化一次。如果没有为它们显式设置值，则初始化所有静态。静态初始化的方式和时间未指定。
C99借用了C ++中的const。另一方面，static一直是许多辩论（两种语言）的来源，因为它经常令人困惑的语义。
此外，使用C ++ 0x直到C ++ 11时，不推荐使用static关键字来声明命名空间范围内的对象。由于各种原因，在C ++ 11中删除了此弃用（请参阅here）。
更长的答案：关键字的更多信息比您想知道的更多（从标准开始）：
公寓
#include <fenv.h>
#pragma STDC FENV_ACCESS ON
/* file scope, static storage, internal linkage */
static int i1; // tentative definition, internal linkage
extern int i1; // tentative definition, internal linkage
int i2; // external linkage, automatic duration (effectively lifetime of program)
int *p = (int []){2, 4}; // unnamed array has static storage
/* effect on string literals */
char *s = "/tmp/fileXXXXXX"; // static storage always, may not be modifiable
char *p = (char []){"/tmp/fileXXXXXX"}; // static, modifiable
const char *cp = (const char []){"/tmp/fileXXXXXX"} // static, non-modifiable
void f(int m)
{
static int vla[ m ]; // err
float w[] = { 0.0/0.0 }; // raises an exception
/* block scope, static storage, no-linkage */
static float x = 0.0/0.0; // does not raise an exception
/* ... */
/* effect on string literals */
char *s = "/tmp/fileXXXXXX"; // static storage always, may not be modifiable
char *p = (char []){"/tmp/fileXXXXXX"}; // automatic storage, modifiable
const char *cp = (const char []){"/tmp/fileXXXXXX"} // automatic storage, non-modifiable
}
inline void bar(void)
{
const static int x = 42; // ok
// Note: Since an inline definition is distinct from the
// corresponding external definition and from any other
// corresponding inline definitions in other translation
// units, all corresponding objects with static storage
// duration are also distinct in each of the definitions
static int y = -42; // error, inline function definition
}
// the last declaration also specifies that the argument
// corresponding to a in any call to f must be a non-null
// pointer to the first of at least three arrays of 5 doubles
void f(double a[static 3][5]);
static void g(void); // internal linkage
C ++
具有相同的语义，除非在简短的回答中指出。此外，没有参数限定statics。
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.
}
class S {
mutable static int i; // err
mutable static int j; // err
static int k; // ok, all instances share the same member
};
inline void bar(void)
{
const static int x = 42; // ok
static int y = -42; // ok
}
我遗漏了C ++的static的一些细微差别。看看书或标准。
静态变量：
Const变量：
常量不能更改，静态变量更多地与它们的分配方式和可访问位置有关。
看看这个site。
类的上下文中的静态变量在类的所有实例之间共享。
在函数中，它仍然是一个持久变量，因此您可以计算函数被调用的次数。
在函数或类之外使用时，它确保变量只能由该特定文件中的代码使用，而不是其他地方。
但是，可以防止常量变量发生变化。 const和static的共同使用是在类定义中提供某种常量。
class myClass {
public:
static const int TOTAL_NUMBER = 5;
// some public stuff
private:
// some stuff
};
const相当于#define，但仅限于价值陈述（例如#define myvalue = 2）。声明的值在编译之前替换变量的名称。
static是一个变量。值可以更改，但即使变量在函数中声明，变量也会在程序执行过程中持续存在。它相当于一个全局变量，其使用范围是它们已声明的块的范围，但它们的值的范围是全局的。
因此，静态变量仅初始化一次。如果变量在函数中声明，这一点尤其重要，因为它保证初始化只会在第一次调用函数时发生。
静力学的另一种用法涉及物体。在对象中声明静态变量会导致该值对于对象的所有实例都相同。因此，不能使用对象的名称调用它，而只能使用类的名称调用它。
public class Test
{
public static int test;
}
Test myTestObject=new Test();
myTestObject.test=2;//ERROR
Test.test=2;//Correct
在像C和C ++这样的语言中，声明静态全局变量是没有意义的，但它们在函数和类中非常有用。在托管语言中，获得全局变量效果的唯一方法是将其声明为静态。
static表示编译单元的本地（即单个C ++源代码文件），或者换句话说，它意味着它不会添加到全局命名空间。您可以在具有相同名称且没有名称冲突的不同c ++源代码文件中具有多个静态变量。
const只是常量，意思是不能修改。
静态变量在类型的所有实例中都很常见。
常量变量特定于某个类型的每个单独实例，但它们的值在编译时是已知的并且是固定的，并且在运行时无法更改。
与常量不同，静态变量值可以在运行时更改。
静态变量只能获得一次初始值。这意味着如果在示例函数中有诸如“static int a=0”之类的代码，并且此代码在第一次调用此函数时执行，而不是在函数的后续调用中执行;变量（a）仍将具有其当前值（例如，当前值为5），因为静态变量仅获得一次初始值。
常量变量的值在整个代码中保持不变。例如，如果将常量变量设置为“const int a=5”，那么“a”的值将在整个程序中保持不变。