Does static make a difference for a const local variable?What is the difference between const and...
insert EOF statement before the last line of file
A starship is travelling at 0.9c and collides with a small rock. Will it leave a clean hole through, or will more happen?
Process to change collation on a database
How would one buy a used TIE Fighter or X-Wing?
Why zero tolerance on nudity in space?
Why does String.replaceAll() work differently in Java 8 from Java 9?
Dilemma of explaining to interviewer that he is the reason for declining second interview
Can a dragon be stuck looking like a human?
Can a person refuse a presidential pardon?
Why are the books in the Game of Thrones citadel library shelved spine inwards?
Is a debit card dangerous for an account with low balance and no overdraft protection?
Why is working on the same position for more than 15 years not a red flag?
How would a Dictatorship make a country more successful?
Why did this image turn out darker?
How do I say "Brexit" in Latin?
Quenching swords in dragon blood; why?
Cryptic with missing capitals
What is better: yes / no radio, or simple checkbox?
Are there neural networks with very few nodes that decently solve non-trivial problems?
Why do members of Congress in committee hearings ask witnesses the same question multiple times?
Why does a metal block make a shrill sound but not a wooden block upon hammering?
Is there any differences between "Gucken" and "Schauen"?
What is the purpose of easy combat scenarios that don't need resource expenditure?
Citing paywalled articles accessed via illegal web sharing
Does static make a difference for a const local variable?
What is the difference between const and readonly?What are the differences between a pointer variable and a reference variable in C++?Are static class variables possible?Difference between static class and singleton pattern?What does “static” mean in C?What is the difference between const int*, const int * const, and int const *?Static variables in JavaScriptWhy are static variables considered evil?Difference between `constexpr` and `const`Replacing a 32-bit loop counter with 64-bit introduces crazy performance deviations
Imagine the following declaration:
void foo(){
const std::array<int, 80000> arr = {/* a lot of different values*/};
//do stuff
}
And a second one:
void foo(){
static const std::array<int, 80000> arr = {/* a lot of different values*/};
//do stuff
}
What are the possible performance differences between these two if any? And is there any danger associated with any of these solutions?
c++ static const
|
show 5 more comments
Imagine the following declaration:
void foo(){
const std::array<int, 80000> arr = {/* a lot of different values*/};
//do stuff
}
And a second one:
void foo(){
static const std::array<int, 80000> arr = {/* a lot of different values*/};
//do stuff
}
What are the possible performance differences between these two if any? And is there any danger associated with any of these solutions?
c++ static const
3
In thestatic
case they may not be on the stack, but in a read-only section. Probably compiler dependent as well.
– Matthieu Brucher
19 hours ago
3
out of curiosity: do you have a real problem at hand, or is this just an academic exercise? (its a valid question in both cases)
– user463035818
19 hours ago
1
@user463035818 I am having discussion during code review ;)
– bartop
19 hours ago
2
depending on the reviewer that can be a real problem :P
– user463035818
19 hours ago
5
@ScheffwithoutStatic
builds the array each times it is invoked from static data (.LC0
).withStatic
uses an array whose construction has been optimized as a constant (withStatic()::arr
).
– YSC
19 hours ago
|
show 5 more comments
Imagine the following declaration:
void foo(){
const std::array<int, 80000> arr = {/* a lot of different values*/};
//do stuff
}
And a second one:
void foo(){
static const std::array<int, 80000> arr = {/* a lot of different values*/};
//do stuff
}
What are the possible performance differences between these two if any? And is there any danger associated with any of these solutions?
c++ static const
Imagine the following declaration:
void foo(){
const std::array<int, 80000> arr = {/* a lot of different values*/};
//do stuff
}
And a second one:
void foo(){
static const std::array<int, 80000> arr = {/* a lot of different values*/};
//do stuff
}
What are the possible performance differences between these two if any? And is there any danger associated with any of these solutions?
c++ static const
c++ static const
edited 14 hours ago
Boann
37.1k1290121
37.1k1290121
asked 19 hours ago
bartopbartop
3,002827
3,002827
3
In thestatic
case they may not be on the stack, but in a read-only section. Probably compiler dependent as well.
– Matthieu Brucher
19 hours ago
3
out of curiosity: do you have a real problem at hand, or is this just an academic exercise? (its a valid question in both cases)
– user463035818
19 hours ago
1
@user463035818 I am having discussion during code review ;)
– bartop
19 hours ago
2
depending on the reviewer that can be a real problem :P
– user463035818
19 hours ago
5
@ScheffwithoutStatic
builds the array each times it is invoked from static data (.LC0
).withStatic
uses an array whose construction has been optimized as a constant (withStatic()::arr
).
– YSC
19 hours ago
|
show 5 more comments
3
In thestatic
case they may not be on the stack, but in a read-only section. Probably compiler dependent as well.
– Matthieu Brucher
19 hours ago
3
out of curiosity: do you have a real problem at hand, or is this just an academic exercise? (its a valid question in both cases)
– user463035818
19 hours ago
1
@user463035818 I am having discussion during code review ;)
– bartop
19 hours ago
2
depending on the reviewer that can be a real problem :P
– user463035818
19 hours ago
5
@ScheffwithoutStatic
builds the array each times it is invoked from static data (.LC0
).withStatic
uses an array whose construction has been optimized as a constant (withStatic()::arr
).
– YSC
19 hours ago
3
3
In the
static
case they may not be on the stack, but in a read-only section. Probably compiler dependent as well.– Matthieu Brucher
19 hours ago
In the
static
case they may not be on the stack, but in a read-only section. Probably compiler dependent as well.– Matthieu Brucher
19 hours ago
3
3
out of curiosity: do you have a real problem at hand, or is this just an academic exercise? (its a valid question in both cases)
– user463035818
19 hours ago
out of curiosity: do you have a real problem at hand, or is this just an academic exercise? (its a valid question in both cases)
– user463035818
19 hours ago
1
1
@user463035818 I am having discussion during code review ;)
– bartop
19 hours ago
@user463035818 I am having discussion during code review ;)
– bartop
19 hours ago
2
2
depending on the reviewer that can be a real problem :P
– user463035818
19 hours ago
depending on the reviewer that can be a real problem :P
– user463035818
19 hours ago
5
5
@Scheff
withoutStatic
builds the array each times it is invoked from static data (.LC0
). withStatic
uses an array whose construction has been optimized as a constant (withStatic()::arr
).– YSC
19 hours ago
@Scheff
withoutStatic
builds the array each times it is invoked from static data (.LC0
). withStatic
uses an array whose construction has been optimized as a constant (withStatic()::arr
).– YSC
19 hours ago
|
show 5 more comments
4 Answers
4
active
oldest
votes
Forget the array for a moment. That muddles two separate issues. You've got answers that address the lifetime and storage issue. I'll address the initialization issue.
void f() {
static const int x = get_x();
// do something with x
}
void g() {
const int x = get_x();
// do something with x
}
The difference between these two is that the first one will only call get_x()
the first time that f()
is called; x
retains that value through the remainder of the program. The second one will call get_x()
each time that g()
is called.
That matters if get_x()
returns different values on subsequent calls:
int current_x = 0;
int get_x() { return current_x++; }
add a comment |
And is there any danger associated with any of these solutions?
Non-static is dangerous because the array is huge, and the memory reserved for automatic storage is limited. Depending on the system and configuration, that array could use about 30% of the space available for automatic storage. As such, it greatly increases the possibility of stack overflow.
While an optimiser might certainly avoid allocating memory on the stack, there are good reasons why you would want your non-optimised debug build to also not crash.
add a comment |
What are the possible performance differences between these two if any?And is there any danger associated with any of these solutions?
The difference depends exactly on how you use foo()
.
1st case:(low probability): Your implementation is such that you will call foo()
only once , maybe you have created separate function to divide code logic as practiced. Well in this case declaring as static is very bad, because a static variable or object remains in memory until programs ends . So just imagine that your variable occupying memory unnecessarily.
2nd case:(high probability): Your implementation is such that you will call foo()
again and again . Then non-static object will get allocated and de allocated again and again.This will take huge amount of cpu clock cycles which is not desired .Use static in this case.
add a comment |
In this particular context, one point to consider regarding using static
on a variable with initialization:
From C++17 standard:
6.7.1 Static storage duration [basic.stc.static]
...
2 If a variable with static storage duration has initialization or a destructor with side effects, it shall not be eliminated even if it appears to be unused, except that a class object or its copy/move may be eliminated as specified in 15.8.
Actually, there are more differences: Its lifetime is different, for one....
– CharonX
15 hours ago
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f54942664%2fdoes-static-make-a-difference-for-a-const-local-variable%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
4 Answers
4
active
oldest
votes
4 Answers
4
active
oldest
votes
active
oldest
votes
active
oldest
votes
Forget the array for a moment. That muddles two separate issues. You've got answers that address the lifetime and storage issue. I'll address the initialization issue.
void f() {
static const int x = get_x();
// do something with x
}
void g() {
const int x = get_x();
// do something with x
}
The difference between these two is that the first one will only call get_x()
the first time that f()
is called; x
retains that value through the remainder of the program. The second one will call get_x()
each time that g()
is called.
That matters if get_x()
returns different values on subsequent calls:
int current_x = 0;
int get_x() { return current_x++; }
add a comment |
Forget the array for a moment. That muddles two separate issues. You've got answers that address the lifetime and storage issue. I'll address the initialization issue.
void f() {
static const int x = get_x();
// do something with x
}
void g() {
const int x = get_x();
// do something with x
}
The difference between these two is that the first one will only call get_x()
the first time that f()
is called; x
retains that value through the remainder of the program. The second one will call get_x()
each time that g()
is called.
That matters if get_x()
returns different values on subsequent calls:
int current_x = 0;
int get_x() { return current_x++; }
add a comment |
Forget the array for a moment. That muddles two separate issues. You've got answers that address the lifetime and storage issue. I'll address the initialization issue.
void f() {
static const int x = get_x();
// do something with x
}
void g() {
const int x = get_x();
// do something with x
}
The difference between these two is that the first one will only call get_x()
the first time that f()
is called; x
retains that value through the remainder of the program. The second one will call get_x()
each time that g()
is called.
That matters if get_x()
returns different values on subsequent calls:
int current_x = 0;
int get_x() { return current_x++; }
Forget the array for a moment. That muddles two separate issues. You've got answers that address the lifetime and storage issue. I'll address the initialization issue.
void f() {
static const int x = get_x();
// do something with x
}
void g() {
const int x = get_x();
// do something with x
}
The difference between these two is that the first one will only call get_x()
the first time that f()
is called; x
retains that value through the remainder of the program. The second one will call get_x()
each time that g()
is called.
That matters if get_x()
returns different values on subsequent calls:
int current_x = 0;
int get_x() { return current_x++; }
answered 17 hours ago
Pete BeckerPete Becker
58.3k442120
58.3k442120
add a comment |
add a comment |
And is there any danger associated with any of these solutions?
Non-static is dangerous because the array is huge, and the memory reserved for automatic storage is limited. Depending on the system and configuration, that array could use about 30% of the space available for automatic storage. As such, it greatly increases the possibility of stack overflow.
While an optimiser might certainly avoid allocating memory on the stack, there are good reasons why you would want your non-optimised debug build to also not crash.
add a comment |
And is there any danger associated with any of these solutions?
Non-static is dangerous because the array is huge, and the memory reserved for automatic storage is limited. Depending on the system and configuration, that array could use about 30% of the space available for automatic storage. As such, it greatly increases the possibility of stack overflow.
While an optimiser might certainly avoid allocating memory on the stack, there are good reasons why you would want your non-optimised debug build to also not crash.
add a comment |
And is there any danger associated with any of these solutions?
Non-static is dangerous because the array is huge, and the memory reserved for automatic storage is limited. Depending on the system and configuration, that array could use about 30% of the space available for automatic storage. As such, it greatly increases the possibility of stack overflow.
While an optimiser might certainly avoid allocating memory on the stack, there are good reasons why you would want your non-optimised debug build to also not crash.
And is there any danger associated with any of these solutions?
Non-static is dangerous because the array is huge, and the memory reserved for automatic storage is limited. Depending on the system and configuration, that array could use about 30% of the space available for automatic storage. As such, it greatly increases the possibility of stack overflow.
While an optimiser might certainly avoid allocating memory on the stack, there are good reasons why you would want your non-optimised debug build to also not crash.
edited 19 hours ago
answered 19 hours ago
eerorikaeerorika
84k662128
84k662128
add a comment |
add a comment |
What are the possible performance differences between these two if any?And is there any danger associated with any of these solutions?
The difference depends exactly on how you use foo()
.
1st case:(low probability): Your implementation is such that you will call foo()
only once , maybe you have created separate function to divide code logic as practiced. Well in this case declaring as static is very bad, because a static variable or object remains in memory until programs ends . So just imagine that your variable occupying memory unnecessarily.
2nd case:(high probability): Your implementation is such that you will call foo()
again and again . Then non-static object will get allocated and de allocated again and again.This will take huge amount of cpu clock cycles which is not desired .Use static in this case.
add a comment |
What are the possible performance differences between these two if any?And is there any danger associated with any of these solutions?
The difference depends exactly on how you use foo()
.
1st case:(low probability): Your implementation is such that you will call foo()
only once , maybe you have created separate function to divide code logic as practiced. Well in this case declaring as static is very bad, because a static variable or object remains in memory until programs ends . So just imagine that your variable occupying memory unnecessarily.
2nd case:(high probability): Your implementation is such that you will call foo()
again and again . Then non-static object will get allocated and de allocated again and again.This will take huge amount of cpu clock cycles which is not desired .Use static in this case.
add a comment |
What are the possible performance differences between these two if any?And is there any danger associated with any of these solutions?
The difference depends exactly on how you use foo()
.
1st case:(low probability): Your implementation is such that you will call foo()
only once , maybe you have created separate function to divide code logic as practiced. Well in this case declaring as static is very bad, because a static variable or object remains in memory until programs ends . So just imagine that your variable occupying memory unnecessarily.
2nd case:(high probability): Your implementation is such that you will call foo()
again and again . Then non-static object will get allocated and de allocated again and again.This will take huge amount of cpu clock cycles which is not desired .Use static in this case.
What are the possible performance differences between these two if any?And is there any danger associated with any of these solutions?
The difference depends exactly on how you use foo()
.
1st case:(low probability): Your implementation is such that you will call foo()
only once , maybe you have created separate function to divide code logic as practiced. Well in this case declaring as static is very bad, because a static variable or object remains in memory until programs ends . So just imagine that your variable occupying memory unnecessarily.
2nd case:(high probability): Your implementation is such that you will call foo()
again and again . Then non-static object will get allocated and de allocated again and again.This will take huge amount of cpu clock cycles which is not desired .Use static in this case.
answered 18 hours ago
Abhishek GargAbhishek Garg
1368
1368
add a comment |
add a comment |
In this particular context, one point to consider regarding using static
on a variable with initialization:
From C++17 standard:
6.7.1 Static storage duration [basic.stc.static]
...
2 If a variable with static storage duration has initialization or a destructor with side effects, it shall not be eliminated even if it appears to be unused, except that a class object or its copy/move may be eliminated as specified in 15.8.
Actually, there are more differences: Its lifetime is different, for one....
– CharonX
15 hours ago
add a comment |
In this particular context, one point to consider regarding using static
on a variable with initialization:
From C++17 standard:
6.7.1 Static storage duration [basic.stc.static]
...
2 If a variable with static storage duration has initialization or a destructor with side effects, it shall not be eliminated even if it appears to be unused, except that a class object or its copy/move may be eliminated as specified in 15.8.
Actually, there are more differences: Its lifetime is different, for one....
– CharonX
15 hours ago
add a comment |
In this particular context, one point to consider regarding using static
on a variable with initialization:
From C++17 standard:
6.7.1 Static storage duration [basic.stc.static]
...
2 If a variable with static storage duration has initialization or a destructor with side effects, it shall not be eliminated even if it appears to be unused, except that a class object or its copy/move may be eliminated as specified in 15.8.
In this particular context, one point to consider regarding using static
on a variable with initialization:
From C++17 standard:
6.7.1 Static storage duration [basic.stc.static]
...
2 If a variable with static storage duration has initialization or a destructor with side effects, it shall not be eliminated even if it appears to be unused, except that a class object or its copy/move may be eliminated as specified in 15.8.
edited 15 hours ago
answered 18 hours ago
P.WP.W
15.4k31453
15.4k31453
Actually, there are more differences: Its lifetime is different, for one....
– CharonX
15 hours ago
add a comment |
Actually, there are more differences: Its lifetime is different, for one....
– CharonX
15 hours ago
Actually, there are more differences: Its lifetime is different, for one....
– CharonX
15 hours ago
Actually, there are more differences: Its lifetime is different, for one....
– CharonX
15 hours ago
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f54942664%2fdoes-static-make-a-difference-for-a-const-local-variable%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
3
In the
static
case they may not be on the stack, but in a read-only section. Probably compiler dependent as well.– Matthieu Brucher
19 hours ago
3
out of curiosity: do you have a real problem at hand, or is this just an academic exercise? (its a valid question in both cases)
– user463035818
19 hours ago
1
@user463035818 I am having discussion during code review ;)
– bartop
19 hours ago
2
depending on the reviewer that can be a real problem :P
– user463035818
19 hours ago
5
@Scheff
withoutStatic
builds the array each times it is invoked from static data (.LC0
).withStatic
uses an array whose construction has been optimized as a constant (withStatic()::arr
).– YSC
19 hours ago