Ggthjy

Help Me simplify: C*(A+B) + ~A*B

Strange Sign on Lab Door

Why is working on the same position for more than 15 years not a red flag?

What is the purpose of easy combat scenarios that don't need resource expenditure?

Does Windows 10's telemetry include sending *.doc files if Word crashed?

Book where aliens are selecting humans for food consumption

Pre-1980's science fiction short story: alien disguised as a woman shot by a gangster, has tentacles coming out of her breasts when remaking her body

A universal method for left-hand alignment of a sequence of equalities

How to acknowledge an embarrassing job interview, now that I work directly with the interviewer?

Explain the objections to these measures against human trafficking

Citing paywalled articles accessed via illegal web sharing

Compress command output by piping to bzip2

The effects of magnetism in radio transmissions

What flying insects could re-enter the Earth's atmosphere from space without burning up?

Disable the ">" operator in Rstudio linux terminal

Is there some relative to Dutch word "kijken" in German?

Why don't American passenger airlines operate dedicated cargo flights any more?

Am I a Rude Number?

Lick explanation

Can a person refuse a presidential pardon?

Why did other German political parties disband so fast when Hitler was appointed chancellor?

Dilemma of explaining to interviewer that he is the reason for declining second interview

Can you earn endless XP using a Flameskull and its self-revival feature?

How do I say "Brexit" in Latin?

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

15

3

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

share|improve this question

edited 11 hours ago

Boann

37.1k1290121

asked 17 hours ago

bartopbartop

3,002827

• 
  
  
  

  
  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
  17 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
  17 hours ago
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  
  @user463035818 I am having discussion during code review ;)
  
  – bartop
  17 hours ago
  

  
  
  
  


• 
  
  
  

  
  2
  

  
  
  
  
  
  

  
  
  depending on the reviewer that can be a real problem :P
  
  – user463035818
  17 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
  16 hours ago
  

  
  
  
  

 | 
show 5 more comments

15

3

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

share|improve this question

edited 11 hours ago

Boann

37.1k1290121

asked 17 hours ago

bartopbartop

3,002827

• 
  
  
  

  
  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
  17 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
  17 hours ago
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  
  @user463035818 I am having discussion during code review ;)
  
  – bartop
  17 hours ago
  

  
  
  
  


• 
  
  
  

  
  2
  

  
  
  
  
  
  

  
  
  depending on the reviewer that can be a real problem :P
  
  – user463035818
  17 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
  16 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

share|improve this question

edited 11 hours ago

Boann

37.1k1290121

asked 17 hours ago

bartopbartop

3,002827

void foo(){

    const std::array<int, 80000> arr = {/* a lot of different values*/};

    //do stuff

}

void foo(){

    static const std::array<int, 80000> arr = {/* a lot of different values*/};

    //do stuff

}

share|improve this question

edited 11 hours ago

Boann

37.1k1290121

asked 17 hours ago

bartopbartop

3,002827

share|improve this question

edited 11 hours ago

Boann

37.1k1290121

asked 17 hours ago

bartopbartop

3,002827

edited 11 hours ago

Boann

37.1k1290121

edited 11 hours ago

Boann

37.1k1290121

asked 17 hours ago

bartopbartop

3,002827

asked 17 hours ago

bartopbartop

3,002827

4 Answers
4

active

oldest

votes

12

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

share|improve this answer

answered 14 hours ago

Pete BeckerPete Becker

58.3k442120

add a comment | 

9

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.

share|improve this answer

edited 16 hours ago

answered 16 hours ago

eerorikaeerorika

84k662128

add a comment | 

3

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.

share|improve this answer

answered 16 hours ago

Abhishek GargAbhishek Garg

1268

add a comment | 

1

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.

share|improve this answer

edited 13 hours ago

answered 15 hours ago

P.WP.W

15.4k31453

• 
  
  
  

  
  

  
  
  
  
  
  

  
  
  Actually, there are more differences: Its lifetime is different, for one....
  
  – CharonX
  13 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
});


}
});

draft saved

draft discarded

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

Name

Email

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

Name

Email

Required, but never shown

12

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

share|improve this answer

answered 14 hours ago

Pete BeckerPete Becker

58.3k442120

add a comment | 

12

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

share|improve this answer

answered 14 hours ago

Pete BeckerPete Becker

58.3k442120

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

share|improve this answer

answered 14 hours ago

Pete BeckerPete Becker

58.3k442120

void f() {

    static const int x = get_x();

    // do something with x

}



void g() {

    const int x = get_x();

    // do something with x

}

int current_x = 0;

int get_x() { return current_x++; }

share|improve this answer

answered 14 hours ago

Pete BeckerPete Becker

58.3k442120

answered 14 hours ago

Pete BeckerPete Becker

58.3k442120

answered 14 hours ago

Pete BeckerPete Becker

58.3k442120

9

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.

share|improve this answer

edited 16 hours ago

answered 16 hours ago

eerorikaeerorika

84k662128

add a comment | 

9

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.

share|improve this answer

edited 16 hours ago

answered 16 hours ago

eerorikaeerorika

84k662128

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.

share|improve this answer

edited 16 hours ago

answered 16 hours ago

eerorikaeerorika

84k662128

share|improve this answer

edited 16 hours ago

answered 16 hours ago

eerorikaeerorika

84k662128

answered 16 hours ago

eerorikaeerorika

84k662128

answered 16 hours ago

eerorikaeerorika

84k662128

3

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.

share|improve this answer

answered 16 hours ago

Abhishek GargAbhishek Garg

1268

add a comment | 

3

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.

share|improve this answer

answered 16 hours ago

Abhishek GargAbhishek Garg

1268

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.

share|improve this answer

answered 16 hours ago

Abhishek GargAbhishek Garg

1268

share|improve this answer

answered 16 hours ago

Abhishek GargAbhishek Garg

1268

answered 16 hours ago

Abhishek GargAbhishek Garg

1268

answered 16 hours ago

Abhishek GargAbhishek Garg

1268

1

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.

share|improve this answer

edited 13 hours ago

answered 15 hours ago

P.WP.W

15.4k31453

• 
  
  
  

  
  

  
  
  
  
  
  

  
  
  Actually, there are more differences: Its lifetime is different, for one....
  
  – CharonX
  13 hours ago
  

  
  
  
  

add a comment | 

1

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.

share|improve this answer

edited 13 hours ago

answered 15 hours ago

P.WP.W

15.4k31453

• 
  
  
  

  
  

  
  
  
  
  
  

  
  
  Actually, there are more differences: Its lifetime is different, for one....
  
  – CharonX
  13 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.

share|improve this answer

edited 13 hours ago

answered 15 hours ago

P.WP.W

15.4k31453

share|improve this answer

edited 13 hours ago

answered 15 hours ago

P.WP.W

15.4k31453

answered 15 hours ago

P.WP.W

15.4k31453

answered 15 hours ago

P.WP.W

15.4k31453