Kan iemand het verschil uitleggen tussen een staticen constvariabele?
Antwoord 1, Autoriteit 100%
Een constante waarde kan niet veranderen. Een statische variabele bestaat in een functie of klasse, in plaats van een instantie of object.
Deze twee concepten zijn niet wederzijds exclusief en kunnen samen worden gebruikt.
Antwoord 2, Autoriteit 68%
Het korte antwoord:
A constis een belofte dat u niet probeert de waarde te wijzigen eenmaal ingesteld.
A staticVariabele betekent dat de levensduur van het object de volledige uitvoering van het programma is en de waarde wordt slechts één keer geïnitialiseerd voor het opstarten van het programma. Alle statica wordt geïnitialiseerd als u niet expliciet een waarde voor hen instelt. De manier en de timing van statische initialisatie is niet-gespecificeerd .
C99 leende het gebruik van constvan C++. Aan de andere kant is staticde bron van vele debatten (in beide talen) vanwege de vaak verwarrende semantiek.
Ook, met C++ 0x tot C++ 11 Het gebruik van de staticis verouderd voor het declareren van objecten in NameSpace Scope. Deze afschrijving werd om verschillende redenen in C++ 11 verwijderd (zie hier ).
Het langere antwoord: meer op de trefwoorden dan u wilde weten (recht van de normen):
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++
Heeft meestal dezelfde semantiek, behalve zoals vermeld in het korte antwoord. Er zijn ook geen parameters die statics kwalificeren.
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
}
Er zijn nog een paar nuances van C++’s staticdie ik hier weglaat. Bekijk een boek of de standaard.
Antwoord 3, autoriteit 26%
Statische variabelen:
- Slechts één keer geïnitialiseerd.
- Statische variabelen zijn voor de klasse (niet per object). d.w.z. geheugen wordt slechts één keer per klasse toegewezen en elke instantie gebruikt het. Dus als een object zijn waarde wijzigt, is de gewijzigde waarde ook zichtbaar voor andere objecten. (Een simpele gedachte.. Om het aantal objecten te kennen dat voor een klasse is gemaakt, kunnen we een statische variabele plaatsen en ++ in de constructor doen)
- Waarde blijft bestaan tussen verschillende functie-aanroepen
Const-variabelen:
- Const-variabelen zijn een belofte dat je de waarde ervan nergens in het programma gaat veranderen. Als je het doet, zal het klagen.
Antwoord 4, autoriteit 14%
constis gelijk aan #definemaar alleen voor waarde-statements (bijv. #define myvalue = 2). De gedeclareerde waarde vervangt de naam van de variabele vóór compilatie.
staticis een variabele. De waarde kan veranderen, maar de variabele blijft bestaantijdens de uitvoering van het programma zelfs als de variabele gedeclareerd is in een functie. Het is gelijk aan een globale variabele waarvan het gebruiksbereik het bereik is van het blok waarin ze zijn gedeclareerd, maar het bereik van hun waarde is globaal.
Als zodanig worden statische variabelen slechts één keer geïnitialiseerd. Dit is vooral belangrijk als de variabele in een functie wordt gedeclareerd, omdat het garandeert dat de initialisatie alleen plaatsvindt bij de eerste aanroep van de functie.
Een ander gebruik van statica heeft betrekking op objecten. Het declareren van een statische variabele in een object heeft tot gevolg dat deze waarde voor alle instanties van het object hetzelfde is. Als zodanig kan het niet worden aangeroepen met de naam van het object, maar alleen met de naam van de klasse.
public class Test
{
public static int test;
}
Test myTestObject=new Test();
myTestObject.test=2;//ERROR
Test.test=2;//Correct
In talen als C en C++ is het zinloos om statische globale variabelen te declareren, maar ze zijn erg handig in functies en klassen.
In beheerde talen is de enige manier om het effect van een globale variabele te hebben, deze als statisch te declareren.
Antwoord 5, autoriteit 10%
Constanten kunnen niet worden gewijzigd, statische variabelen hebben meer te maken met hoe ze worden toegewezen en waar ze toegankelijk zijn.
Bekijk deze site.
Antwoord 6, autoriteit 8%
Een statische variabele kan slechts één keer een beginwaarde krijgen. Dit betekent dat als je code zoals “static int a=0” in een voorbeeldfunctie hebt, en deze code wordt uitgevoerd in een eerste aanroep van deze functie, maar niet uitgevoerd in een volgende aanroep van de functie; variabele (a) heeft nog steeds zijn huidige waarde (bijvoorbeeld een huidige waarde van 5), omdat de statische variabele slechts één keer een initiële waarde krijgt.
Een constante variabele heeft zijn waarde constant in de hele code. Als u bijvoorbeeld de constante variabele instelt zoals “const int a=5“, dan is deze waarde voor “a” constant in uw hele programma.
Antwoord 7, autoriteit 8%
static is a storage specifier.
const is a type qualifier.
Antwoord 8, autoriteit 6%
Statische variabelen in de context van een klasse worden gedeeld tussen alle instanties van een klasse.
In een functie blijft het een persistente variabele, dus je zou bijvoorbeeld kunnen tellen hoe vaak een functie is aangeroepen.
Als het buiten een functie of klasse wordt gebruikt, zorgt het ervoor dat de variabele alleen kan worden gebruikt door code in dat specifieke bestand, en nergens anders.
Constante variabelen kunnen echter niet veranderen. Een algemeen gebruik van const en static samen valt binnen een klassedefinitie om een soort constante te bieden.
class myClass {
public:
static const int TOTAL_NUMBER = 5;
// some public stuff
private:
// some stuff
};
Antwoord 9, autoriteit 4%
statisch betekent lokaal voor de compilatie-eenheid (d.w.z. een enkel C++-broncodebestand), of met andere woorden, het betekent dat het niet wordt toegevoegd aan een globale naamruimte. u kunt meerdere statische variabelen in verschillende c++-broncodebestanden hebben met de dezelfdenaam en geen naamconflicten.
const is gewoon constant, wat betekent dat het niet kan worden gewijzigd.
Antwoord 10, autoriteit 4%
Statische variabelen komen voor in alle instanties van een type.
constante variabelen zijn specifiek voor elke individuele instantie van een type, maar hun waarden zijn bekend en vastgelegd tijdens het compileren en kunnen niet tijdens runtime worden gewijzigd.
in tegenstelling tot constanten, kunnen waarden van statische variabelen tijdens runtime worden gewijzigd.
Antwoord 11, autoriteit 2%
Const betekent “kan niet worden gewijzigd.”
Statisch betekent “statische instantie (in geheugen)versus dynamische instantie (op de stapel)”. Statische variabelen bestaan voor de duur van het programma. Dynamische worden gemaakt en vernietigd als dat nodig is.
Een variabele kan een of beide zijn.
Antwoord 12
const betekent constant en hun waarden worden gedefinieerd tijdens het compileren in plaats van expliciet te veranderen tijdens runtime, de waarde van constant kan niet worden gewijzigd tijdens runtime
Statische variabelen zijn echter variabelen die tijdens runtime kunnen worden geïnitialiseerd en gewijzigd. Statische variabelen verschillen echter van de variabelen in die zin dat statische variabelen hun waarden behouden voor het hele programma, dwz hun levensduur is van het programma of totdat het geheugen door het programma wordt toegewezen met behulp van de dynamische toewijzingsmethode. Hoewel ze hun waarden gedurende de hele levensduur van het programma behouden, zijn ze echter niet toegankelijk buiten het codeblok waarin ze zich bevinden
Voor meer informatie over statische variabelen, raadpleeg hier
Antwoord 13
Constante variabelen kunnen niet worden gewijzigd. Statische variabelen zijn privé voor het bestand en zijn alleen toegankelijk binnen de programmacode en niet voor iemand anders.
Antwoord 14
statictrefwoord definieert het bereik van variabelen terwijl consttrefwoord de waarde definieert van de variabele die niet kan worden gewijzigd tijdens de uitvoering van het programma
Antwoord 15
Een eenvoudig en kort antwoord is dat geheugen slechts één keer wordt toegewezen aan static en const. Maar in principe is dat voor slechts één waarde waar zoals in statische waarden kunnen veranderen, maar het geheugengebied blijft hetzelfde tot het einde van het programma.
Antwoord 16
statisch
wordt gebruikt om van de variabele een klassevariabele te maken. U hoeft geen statische variabele te definiëren tijdens het declareren.
Voorbeeld:
#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;
}
Dit zou het volgende afdrukken:
Dum van object afdrukken: 1
Dum uit de klas printen: 1
De variabele dum is een klassevariabele. Als je probeert er toegang toe te krijgen via een object, informeert de compiler alleen dat het een variabele is van welke klasse.
Overweeg een scenario waarin u een variabele kunt gebruiken om het aantal gemaakte objecten te tellen. static zou daar van pas komen.
const
wordt gebruikt om er een alleen-lezen variabele van te maken. U moet de variabele const in één keer definiëren en declareren.
Laten we in hetzelfde programma als hierboven genoemd ook een const maken:
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
};
Stel dat ik in het algemeen dit doe:
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;
}
Hoewel static beheersbaar was om te begrijpen, is const in c++ in de war. De volgende bron helpt om het beter te begrijpen:
http://duramecho.com/ComputerInformation/WhyHowCppConst.html
Antwoord 17
statische waarde kan bestaan in een functie en kan in verschillende vormen worden gebruikt en kan verschillende waarde hebben in het programma.
Ook tijdens het programma kan hun waarde na increment of decrement veranderen, maar constant blijven gedurende het hele programma.