static和const变量有什么区别？

Posted 2021-04-26

有人可以解释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变量：

• 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”的值将在整个程序中保持不变。