it-swarm.com.de

Was ist der Unterschied zwischen einer statischen und einer const-Variablen?

Kann jemand den Unterschied zwischen einer Variablen static und const erklären?

56
jaimin

Ein konstanter Wert kann sich nicht ändern. Anstelle einer Instanz oder eines Objekts existiert eine statische Variable für eine Funktion oder Klasse.

Diese beiden Konzepte schließen sich nicht gegenseitig aus und können zusammen verwendet werden.

38
Stefan Kendall

Die kurze Antwort:

Eine const ist ein Versprechen, dass Sie nicht versuchen, den einmal festgelegten Wert zu ändern. 

Eine Variable static bedeutet, dass die Lebensdauer des Objekts die gesamte Ausführung des Programms ist und der Wert nur einmal vor dem Programmstart initialisiert wird. Alle Statiken werden initialisiert, wenn Sie nicht explizit einen Wert für sie festlegen. Die Art und der Zeitpunkt der statischen Initialisierung lautet unspecified.

C99 hat die Verwendung von const aus C++ entlehnt. Andererseits ist static aufgrund ihrer oft verwirrenden Semantik die Quelle vieler Debatten (in beiden Sprachen) gewesen.

Mit C++ 0x bis C++ 11 wurde die Verwendung des Schlüsselworts static für das Deklarieren von Objekten im Namespacebereich nicht mehr empfohlen. Diese Abwertung wurde aus verschiedenen Gründen in C++ 11 entfernt (siehe hier ).

Die längere Antwort: Mehr zu den Keywords, als Sie wollten (direkt von den Standards):

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++

Hat meistens die gleiche Semantik, außer wie in der kurzen Antwort angegeben. Es gibt auch keine Parameter, die statics qualifizieren. 

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
}

Es gibt noch ein paar Nuancen von C++ static, die ich hier auslasse. Schauen Sie sich ein Buch oder den Standard an.

22
dirkgently

Statische Variablen:

  • Nur einmal initialisiert.
  • Statische Variablen beziehen sich auf die Klasse (nicht pro Objekt). Der Speicher wird nur einmal pro Klasse zugewiesen und jede Instanz verwendet ihn. Wenn also ein Objekt seinen Wert ändert, ist der geänderte Wert auch für andere Objekte sichtbar. (Ein einfacher Gedanke. Um die Anzahl der für eine Klasse erstellten Objekte zu kennen, können wir eine statische Variable und do ++ in den Konstruktor einfügen.
  • Der Wert bleibt zwischen verschiedenen Funktionsaufrufen bestehen

Const-Variablen:

  • Const-Variablen sind ein Versprechen, dass Sie den Wert nirgendwo im Programm ändern. Wenn Sie es tun, wird es sich beschweren.
7
user3681970

Konstanten können nicht geändert werden, statische Variablen haben mehr zu tun, wie sie zugewiesen werden und wo sie zugänglich sind.

Schauen Sie sich diese Site an.

5
H. Green

Statische Variablen im Kontext einer Klasse werden von allen Instanzen einer Klasse gemeinsam genutzt.

In einer Funktion bleibt sie eine persistente Variable, so dass Sie beispielsweise zählen können, wie oft eine Funktion aufgerufen wurde.

Bei Verwendung außerhalb einer Funktion oder Klasse wird sichergestellt, dass die Variable nur von Code in dieser bestimmten Datei verwendet werden kann und an keiner anderen Stelle.

Konstante Variablen werden jedoch daran gehindert, sich zu ändern. Eine häufige Verwendung von const und static zusammen ist eine Klassendefinition, um eine Art Konstante bereitzustellen. 

class myClass {
public:
     static const int TOTAL_NUMBER = 5;
     // some public stuff
private:
     // some stuff
};
3
Xorlev

const entspricht #define, jedoch nur für Wertanweisungen (z. B. #define myvalue = 2). Der deklarierte Wert ersetzt den Namen der Variablen vor der Kompilierung.

static ist eine Variable. Der Wert kann sich ändern, aber die Variable wird persistent ​​während der Ausführung des Programms auch wenn die Variable in einer Funktion deklariert ist. Dies entspricht einer globalen Variablen, deren Verwendungsbereich der Bereich des Blocks ist, in dem sie deklariert wurden. Der Bereich ihres Werts ist jedoch global.

Als solche sind statische Variablen nur einmal initialisiert. Dies ist besonders wichtig, wenn die Variable in einer Funktion deklariert ist, da sie garantiert, dass die Initialisierung nur beim ersten Aufruf der Funktion erfolgt.

Eine andere Verwendung der Statik betrifft Objekte. Das Deklarieren einer statischen Variablen in einem Objekt hat zur Folge, dass dieser Wert für alle Instanzen des Objekts gleich ist. Daher kann es nicht mit dem Namen des Objekts aufgerufen werden, sondern nur mit dem Namen der Klasse.

public class Test 
{ 
    public static int test;
}
Test myTestObject=new Test();
myTestObject.test=2;//ERROR
Test.test=2;//Correct

In Sprachen wie C und C++ ist es sinnlos, statische globale Variablen zu deklarieren, aber sie sind in Funktionen und Klassen sehr nützlich. In verwalteten Sprachen kann eine globale Variable nur als statisch deklariert werden.

3
ThunderGr

statisch bedeutet lokal für die Kompilierungseinheit (d. h. eine einzelne C++ - Quellcodedatei), oder anders ausgedrückt, es wird nicht zu einem globalen Namespace hinzugefügt. Sie können mehrere statische Variablen in verschiedenen C++ - Quellcodedateien mit dem Namen same name und keinem Namenskonflikt haben.

const ist nur konstant, die Bedeutung kann nicht geändert werden.

2
invalidopcode

Statische Variablen gelten für alle Instanzen eines Typs.

konstante Variablen sind für jede einzelne Instanz eines Typs spezifisch, aber ihre Werte sind zur Kompilierzeit bekannt und festgelegt und können zur Laufzeit nicht geändert werden.

im Gegensatz zu Konstanten können statische Variablenwerte zur Laufzeit geändert werden.

Eine statische Variable kann nur einmal einen Anfangswert erhalten. Das bedeutet, wenn Sie Code wie "static int a=0" in einer Beispielfunktion haben und dieser Code beim ersten Aufruf dieser Funktion ausgeführt wird, bei einem nachfolgenden Aufruf der Funktion jedoch nicht; Variable (a) hat immer noch ihren aktuellen Wert (zum Beispiel einen aktuellen Wert von 5), da die statische Variable nur einmal einen Anfangswert erhält.

Eine konstante Variable hat ihren Wert im gesamten Code. Wenn Sie beispielsweise die konstante Variable wie "const int a=5" setzen, ist dieser Wert für "a" in Ihrem gesamten Programm konstant.

2
celine

Das Schlüsselwort static definiert den Umfang der Variablen, während das Schlüsselwort const den Wert der Variablen definiert, der während der Programmausführung nicht geändert werden kann 

0
sumera

Einfache und kurze Antwort: Speicher wird für statisch und const nur einmal zugewiesen. In const ist dies jedoch nur für einen Wert, bei dem sich die statischen Werte ändern können, der Speicherbereich jedoch bis zum Ende des Programms unverändert bleibt.

0
shivapola

statisch

wird verwendet, um aus der Variablen eine Klassenvariable zu machen. Sie müssen während der Deklaration keine statische Variable definieren.

Beispiel:

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

Dies würde Folgendes drucken: Druckdum aus Objekt: 1 Druckdum aus Klasse: 1

Die Variable dum ist eine Klassenvariable. Der Versuch, über ein Objekt darauf zuzugreifen, informiert den Compiler lediglich darüber, dass es sich bei dieser Klasse um eine Variable handelt. Stellen Sie sich ein Szenario vor, in dem Sie eine Variable verwenden können, um die Anzahl der erstellten Objekte zu zählen. statisch wäre da praktisch.

const

wird verwendet, um eine schreibgeschützte Variable zu erstellen. Sie müssen die const-Variable sofort definieren und deklarieren.

In dem gleichen Programm, das oben erwähnt wurde, machen wir den Dum ebenfalls zu einem 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

};

Angenommen, ich mache das im Wesentlichen:

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

Obwohl statisch manches verstehen kann, ist const in c ++ durcheinander geraten. Die folgende Ressource hilft dabei, es besser zu verstehen: http://duramecho.com/ComputerInformation/WhyHowCppConst.html

0
Aparna

Const bedeutet "kann nicht geändert werden."

Static bedeutet "statische Instanz (im Speicher) vs dynamische Instanz (auf dem Stack)". Statische Variablen sind für die Dauer des Programms vorhanden. Dynamische werden erstellt und bei Bedarf zerstört.

Eine Variable kann eine oder beide sein.

0
Kiki Jewell

Konstante Variablen können nicht geändert werden. Statische Variablen sind für die Datei privat und nur innerhalb des Programmcodes und nicht für andere Personen zugänglich.

0
user266117

const bedeutet konstant und ihre Werte werden zur Kompilierzeit definiert, anstatt sie auch zur Laufzeit explizit zu ändern. Der Wert der Konstanten kann nicht zur Laufzeit geändert werden

Statische Variablen sind jedoch Variablen, die zur Laufzeit initialisiert und geändert werden können. Statisch unterscheidet sich von den Variablen jedoch dahingehend, dass statische Variablen ihre Werte für das gesamte Programm beibehalten, d. H. Ihre Lebensdauer ist das Programm oder bis der Speicher durch das Programm mit Hilfe der dynamischen Zuweisungsmethode zugeteilt wird. Obwohl sie ihre Werte für die gesamte Lebensdauer des Programms beibehalten, sind sie außerhalb des Codeblocks, in dem sie sich befinden, nicht zugänglich

Weitere Informationen zu statischen Variablen finden Sie unter hier

0
manugupt1