静态变量和常量变量有什么区别?

有人可以解释staticconst变量之间的区别吗?

jaimin asked 2019-10-09T11:10:49Z
16个解决方案
38 votes

常数值不能改变。 函数或类(而不是实例或对象)存在静态变量。

这两个概念不是互相排斥的,可以一起使用。

Stefan Kendall answered 2019-10-09T11:11:08Z
24 votes

简短的答案:

一个static保证您一旦设置就不会尝试修改该值。

static变量表示对象的生存期是程序的整个执行过程,并且其值仅在程序启动之前初始化一次。 如果未明确为其设置值,则将初始化所有静态变量。静态初始化的方式和时间未指定。

C99从C ++借用了static。 另一方面,由于其语义常常令人困惑,因此static成为了许多辩论的源泉(使用两种语言)。

同样,对于C ++ 0x直到C ++ 11,不建议使用static关键字在命名空间范围内声明对象。 由于各种原因,C ++ 11中已删除了此弃用(请参见此处)。

更长的答案:关于关键字的信息超出了您想知道的范围(根据标准):

C99

#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的更多细微差别。 看一本书或标准。

dirkgently answered 2019-10-09T11:12:28Z
7 votes

静态变量:

  • 仅初始化一次。
  • 静态变量适用于类(不适用于每个对象)。 即每个类仅分配一次内存,每个实例都使用它。 因此,如果一个对象修改了它的值,那么修改后的值对其他对象也是可见的。 (一个简单的想法。要知道为一个类创建的对象数量,我们可以放置一个静态变量,并在构造函数中执行++)
  • 值在不同的函数调用之间持续存在

常量变量:

  • 常量变量是一个保证,您将不会在程序中的任何位置更改其值。 如果这样做,它将抱怨。
user3681970 answered 2019-10-09T11:13:30Z
5 votes

常量不能更改,静态变量与它们的分配方式和可访问性息息相关。

看看这个网站。

H. Green answered 2019-10-09T11:14:03Z
3 votes

类上下文中的静态变量在类的所有实例之间共享。

在函数中,它仍然是一个持久变量,因此您可以例如计算一个函数被调用的次数。

当在函数或类之外使用时,它确保变量只能由该特定文件中的代码使用,而不能在其他任何地方使用。

但是,常量变量无法更改。 const和static的共同用法是在类定义中提供某种常量。

class myClass {
public:
     static const int TOTAL_NUMBER = 5;
     // some public stuff
private:
     // some stuff
};
Xorlev answered 2019-10-09T11:14:51Z
3 votes

static等效于#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 ++这样的语言中,声明静态全局变量是没有意义的,但是它们在函数和类中非常有用。在托管语言中,影响全局变量的唯一方法是将其声明为静态。

ThunderGr answered 2019-10-09T11:15:48Z
2 votes

static表示对于编译单元而言是本地的(即单个C ++源代码文件),换句话说,这意味着它不会被添加到全局名称空间中。 您可以在不同的c ++源代码文件中使用相同的名称且没有名称冲突的多个静态变量。

const只是常量,表示无法修改。

invalidopcode answered 2019-10-09T11:16:22Z
2 votes

静态变量在类型的所有实例之间都是通用的。

常数变量是特定于某个类型的每个实例的,但是它们的值是已知的,并且在编译时是固定的,并且不能在运行时更改。

与常量不同,静态变量值可以在运行时更改。

this. __curious_geek answered 2019-10-09T11:17:00Z
2 votes

静态变量只能一次获得初始值。 这意味着如果示例函数中有诸如“ const int a=5”之类的代码,并且此代码在该函数的第一次调用中执行,但在该函数的后续调用中未执行; 变量(a)仍将具有其当前值(例如,当前值为5),因为静态变量仅一次获得初始值。

常量变量在整个代码中的值都是常量。 例如,如果将常量变量设置为“ const int a=5”,则“ a”的此值在整个程序中将是常量。

celine answered 2019-10-09T11:17:36Z
0 votes

const表示常量,常量的值是在编译时定义的,而不是在运行时显式更改的,常量的值不能在运行时更改

但是,静态变量是可以在运行时初始化和更改的变量。 但是,静态变量与变量有所不同,静态变量在整个程序中都保留其值,即它们的生命周期是程序的寿命,或者直到使用动态分配方法由程序取消分配内存为止。 但是,即使它们在程序的整个生命周期中都保留了它们的值,也无法从它们所在的代码块中访问它们。

有关静态变量的更多信息,请参见此处

manugupt1 answered 2019-10-09T11:18:18Z
0 votes

常量变量不能更改。 静态变量是文件专用的,只能在程序代码中访问,其他任何人都不能访问。

user266117 answered 2019-10-09T11:18:45Z
0 votes

static关键字定义变量的范围,而const关键字定义程序执行期间无法更改的变量的值

sumera answered 2019-10-09T11:19:12Z
0 votes

简单而简短的答案是,内存仅分配给static和const一次。 但是在const中,仅适用于一个值,其中静态值可能会更改,但内存区域将保持不变,直到程序结束。

shivapola answered 2019-10-09T11:19:39Z
0 votes

const表示“无法更改”。

静态表示“静态实例(在内存中)与动态实例(在堆栈上)。”静态变量在程序运行期间一直存在。 动态的将根据需要创建和销毁。

变量可以是一个或两个。

Kiki Jewell answered 2019-10-09T11:20:19Z
0 votes

静态的

用于使变量成为类变量。 声明时无需定义静态变量。

例:

#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;
}

这将打印:从对象打印假对象:1班级印刷假面:1

变量dum是类变量。 尝试通过对象访问它只是通知编译器它是哪个类的变量。考虑一种方案,其中您可以使用变量来计数创建的对象数。 静态在那里会派上用场。

const

用于使其成为只读变量。 您需要立即定义并声明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;
}

尽管可以理解static是易于管理的,但在C ++中却弄糟了const。 以下资源有助于更好地理解它:[http://duramecho.com/ComputerInformation/WhyHowCppConst.html]

Aparna answered 2019-10-09T11:21:45Z
-3 votes

静态值可以存在于函数中,并且可以以不同的形式使用,并且在程序中可以具有不同的值。同样,在程序中,递减后的值可能会更改,但是在整个程序中常量保持不变。

kanwal kumar maheshwari answered 2019-10-09T11:22:14Z
translate from https://stackoverflow.com:/questions/2216239/what-is-the-difference-between-a-static-and-const-variable