How Should I Define/Declare String Constants
Clash Royale CLAN TAG#URR8PPP
I've always used string constants in C as one of the following
char *filename = "foo.txt";
const char *s = "bar"; /* preferably this or the next one */
const char * const s3 = "baz":
But, after reading this, now I'm wondering, should I be declaring my string constants as
const char s4 = "bux";
?
Please note that linked question suggested as a duplicate is different because this one is specifically asking about constant strings. I know how the types are different and how they are stored. The array version in that question is not const
-qualified. This was a simple question as to whether I should use constant array for constant strings vs. the pointer version I had been using. The answers here have answered my question, when two days of searching on SO and Google did not yield an exact answer. Thanks to these answers, I've learned that the compiler can do special things when the array is marked const
, and there are indeed (at least one) case where I will now be using the array version.
c
|
show 7 more comments
I've always used string constants in C as one of the following
char *filename = "foo.txt";
const char *s = "bar"; /* preferably this or the next one */
const char * const s3 = "baz":
But, after reading this, now I'm wondering, should I be declaring my string constants as
const char s4 = "bux";
?
Please note that linked question suggested as a duplicate is different because this one is specifically asking about constant strings. I know how the types are different and how they are stored. The array version in that question is not const
-qualified. This was a simple question as to whether I should use constant array for constant strings vs. the pointer version I had been using. The answers here have answered my question, when two days of searching on SO and Google did not yield an exact answer. Thanks to these answers, I've learned that the compiler can do special things when the array is marked const
, and there are indeed (at least one) case where I will now be using the array version.
c
1
Interesting.. The author is correct - "arrays" ARE different from "pointers". And I would have THOUGHT that the pointer syntax (e.g.const char *s = "bar";
) was generally "preferred". I'm surprised with his conclusions that "array syntax" is actually more efficient - with different compilers, and on different platforms.
– paulsm4
Mar 4 at 1:52
Indeed. I always usedconst char *s = "bar";
where I could. I never really thought to use a const-char array. I've been trying to find a solid answer for 2 days so I figured I had to ask here :P. I realize that I can usesizeof
with the array version, but that isn't really too important at least in my current case. I'm wondering, with this author's considerations, what the general approach should be.
– RastaJedi
Mar 4 at 1:54
1
Seems like a micro-optimization to me.
– dbush
Mar 4 at 1:58
I had another pro-array version link I was reading, that was talking about the overhead of using the pointer version. I can't seem to find it right now but I'll post back if I do. And @dbush, I'm sure, but I don't know if I have OCD or what, but I get real picky about real mundane stuff haha.
– RastaJedi
Mar 4 at 2:01
1
In Apple LLVM 10,0.0 with clang-1000.11.45.5, the difference vanishes if you insertconst
after*
inconst char *ptr = "Lorum ipsum";
. The fact the compiler had to loadptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointerconst
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.
– Eric Postpischil
Mar 4 at 2:10
|
show 7 more comments
I've always used string constants in C as one of the following
char *filename = "foo.txt";
const char *s = "bar"; /* preferably this or the next one */
const char * const s3 = "baz":
But, after reading this, now I'm wondering, should I be declaring my string constants as
const char s4 = "bux";
?
Please note that linked question suggested as a duplicate is different because this one is specifically asking about constant strings. I know how the types are different and how they are stored. The array version in that question is not const
-qualified. This was a simple question as to whether I should use constant array for constant strings vs. the pointer version I had been using. The answers here have answered my question, when two days of searching on SO and Google did not yield an exact answer. Thanks to these answers, I've learned that the compiler can do special things when the array is marked const
, and there are indeed (at least one) case where I will now be using the array version.
c
I've always used string constants in C as one of the following
char *filename = "foo.txt";
const char *s = "bar"; /* preferably this or the next one */
const char * const s3 = "baz":
But, after reading this, now I'm wondering, should I be declaring my string constants as
const char s4 = "bux";
?
Please note that linked question suggested as a duplicate is different because this one is specifically asking about constant strings. I know how the types are different and how they are stored. The array version in that question is not const
-qualified. This was a simple question as to whether I should use constant array for constant strings vs. the pointer version I had been using. The answers here have answered my question, when two days of searching on SO and Google did not yield an exact answer. Thanks to these answers, I've learned that the compiler can do special things when the array is marked const
, and there are indeed (at least one) case where I will now be using the array version.
c
c
edited Mar 7 at 17:17
RastaJedi
asked Mar 4 at 1:47
RastaJediRastaJedi
5061417
5061417
1
Interesting.. The author is correct - "arrays" ARE different from "pointers". And I would have THOUGHT that the pointer syntax (e.g.const char *s = "bar";
) was generally "preferred". I'm surprised with his conclusions that "array syntax" is actually more efficient - with different compilers, and on different platforms.
– paulsm4
Mar 4 at 1:52
Indeed. I always usedconst char *s = "bar";
where I could. I never really thought to use a const-char array. I've been trying to find a solid answer for 2 days so I figured I had to ask here :P. I realize that I can usesizeof
with the array version, but that isn't really too important at least in my current case. I'm wondering, with this author's considerations, what the general approach should be.
– RastaJedi
Mar 4 at 1:54
1
Seems like a micro-optimization to me.
– dbush
Mar 4 at 1:58
I had another pro-array version link I was reading, that was talking about the overhead of using the pointer version. I can't seem to find it right now but I'll post back if I do. And @dbush, I'm sure, but I don't know if I have OCD or what, but I get real picky about real mundane stuff haha.
– RastaJedi
Mar 4 at 2:01
1
In Apple LLVM 10,0.0 with clang-1000.11.45.5, the difference vanishes if you insertconst
after*
inconst char *ptr = "Lorum ipsum";
. The fact the compiler had to loadptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointerconst
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.
– Eric Postpischil
Mar 4 at 2:10
|
show 7 more comments
1
Interesting.. The author is correct - "arrays" ARE different from "pointers". And I would have THOUGHT that the pointer syntax (e.g.const char *s = "bar";
) was generally "preferred". I'm surprised with his conclusions that "array syntax" is actually more efficient - with different compilers, and on different platforms.
– paulsm4
Mar 4 at 1:52
Indeed. I always usedconst char *s = "bar";
where I could. I never really thought to use a const-char array. I've been trying to find a solid answer for 2 days so I figured I had to ask here :P. I realize that I can usesizeof
with the array version, but that isn't really too important at least in my current case. I'm wondering, with this author's considerations, what the general approach should be.
– RastaJedi
Mar 4 at 1:54
1
Seems like a micro-optimization to me.
– dbush
Mar 4 at 1:58
I had another pro-array version link I was reading, that was talking about the overhead of using the pointer version. I can't seem to find it right now but I'll post back if I do. And @dbush, I'm sure, but I don't know if I have OCD or what, but I get real picky about real mundane stuff haha.
– RastaJedi
Mar 4 at 2:01
1
In Apple LLVM 10,0.0 with clang-1000.11.45.5, the difference vanishes if you insertconst
after*
inconst char *ptr = "Lorum ipsum";
. The fact the compiler had to loadptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointerconst
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.
– Eric Postpischil
Mar 4 at 2:10
1
1
Interesting.. The author is correct - "arrays" ARE different from "pointers". And I would have THOUGHT that the pointer syntax (e.g.
const char *s = "bar";
) was generally "preferred". I'm surprised with his conclusions that "array syntax" is actually more efficient - with different compilers, and on different platforms.– paulsm4
Mar 4 at 1:52
Interesting.. The author is correct - "arrays" ARE different from "pointers". And I would have THOUGHT that the pointer syntax (e.g.
const char *s = "bar";
) was generally "preferred". I'm surprised with his conclusions that "array syntax" is actually more efficient - with different compilers, and on different platforms.– paulsm4
Mar 4 at 1:52
Indeed. I always used
const char *s = "bar";
where I could. I never really thought to use a const-char array. I've been trying to find a solid answer for 2 days so I figured I had to ask here :P. I realize that I can use sizeof
with the array version, but that isn't really too important at least in my current case. I'm wondering, with this author's considerations, what the general approach should be.– RastaJedi
Mar 4 at 1:54
Indeed. I always used
const char *s = "bar";
where I could. I never really thought to use a const-char array. I've been trying to find a solid answer for 2 days so I figured I had to ask here :P. I realize that I can use sizeof
with the array version, but that isn't really too important at least in my current case. I'm wondering, with this author's considerations, what the general approach should be.– RastaJedi
Mar 4 at 1:54
1
1
Seems like a micro-optimization to me.
– dbush
Mar 4 at 1:58
Seems like a micro-optimization to me.
– dbush
Mar 4 at 1:58
I had another pro-array version link I was reading, that was talking about the overhead of using the pointer version. I can't seem to find it right now but I'll post back if I do. And @dbush, I'm sure, but I don't know if I have OCD or what, but I get real picky about real mundane stuff haha.
– RastaJedi
Mar 4 at 2:01
I had another pro-array version link I was reading, that was talking about the overhead of using the pointer version. I can't seem to find it right now but I'll post back if I do. And @dbush, I'm sure, but I don't know if I have OCD or what, but I get real picky about real mundane stuff haha.
– RastaJedi
Mar 4 at 2:01
1
1
In Apple LLVM 10,0.0 with clang-1000.11.45.5, the difference vanishes if you insert
const
after *
in const char *ptr = "Lorum ipsum";
. The fact the compiler had to load ptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointer const
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.– Eric Postpischil
Mar 4 at 2:10
In Apple LLVM 10,0.0 with clang-1000.11.45.5, the difference vanishes if you insert
const
after *
in const char *ptr = "Lorum ipsum";
. The fact the compiler had to load ptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointer const
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.– Eric Postpischil
Mar 4 at 2:10
|
show 7 more comments
3 Answers
3
active
oldest
votes
Pointer and arrays are different. Defining string constants as pointers or arrays fits different purposes.
When you define a global string constant that is not subject to change, I would recommend you make it a const array:
const char product_name = "The program version 3";
Defining it as const char *product_name = "The program version 3";
actually defines 2 objects: the string constant itself, which will reside in a constant segment, and the pointer which can be changed to point to another string or set to NULL
.
Conversely, defining a string constant as a local variable would be better done as a local pointer variable of type const char *
, initialized with the address of a string constant:
int main()
const char *s1 = "world";
printf("Hello %sn", s1);
return 0;
If you define this one as an array, depending on the compiler and usage inside the function, the code will make space for the array on the stack and initialize it by copying the string constant into it, a more costly operation for long strings.
Note also that const char const *s3 = "baz";
is a redundant form of const char *s3 = "baz";
. It is different from const char * const s3 = "baz";
which defines a constant pointer to a constant array of characters.
Finally, string constants are immutable and as such should have type const char
. The C Standard purposely allows programmers to store their addresses into non const pointers as in char *s2 = "hello";
to avoid producing warnings for legacy code. In new code, it is highly advisable to always use const char *
pointers to manipulate string constants. This may force you to declare function arguments as const char *
when the function does not change the string contents. This process is known as constification and avoid subtile bugs.
Note that some functions violate this const
propagation: strchr()
does not modify the string received, declared as const char *
, but returns a char *
. It is therefore possible to store a pointer to a string constant into a plain char *
pointer this way:
char *p = strchr("Hello Worldn", 'H');
This problem is solved in C++ via overloading. C programmers must deal with this as a shortcoming. An even more annoying situation is that of strtol()
where the address of a char *
is passed and a cast is required to preserve proper constness.
Sorry,const char *const s3
is what I meant to type. Fixed it now :). So for global, using the array version won't result in a copy?
– RastaJedi
Mar 4 at 2:32
To the extent that you would get a "redundant" pointer variable in thes1
case, aren't you prone to a "redundant" array copy in theproduct_name
case (for them's the semantics) which is far worse? I've never heard this advice before tbh.
– Lightness Races in Orbit
Mar 4 at 2:35
@LightnessRacesinOrbit: in the case of a global variable, the is no copy at runtime but indeed the string constant may be duplicated in the binary file and in memory:const char *s1 = "toto", *s2 = "toto";
may initialize boths1
ands2
to the same value whereasconst char s1 = "toto", s2 = "toto";
defines 2 separate objects each with the same duplicated contents.
– chqrlie
Mar 4 at 2:38
Right, and doesn't that suggest thatconst char*
is a much superior choice?
– Lightness Races in Orbit
Mar 4 at 2:39
1
I've marked this as the accepted answer because this answers my 'how should I declare' question more directly, although the information in @EricPostpischil's answer directly comments on the information provided in my source link. Unfortunately I cannot accept two answers, but I urge all of you who are reading this answer to also view his answer. Thank you all!
– RastaJedi
Mar 4 at 3:02
|
show 4 more comments
The linked article explores a small artificial situation, and the difference demonstrated vanishes if you insert const
after *
in const char *ptr = "Lorum ipsum";
(tested in Apple LLVM 10.0.0 with clang-1000.11.45.5).
The fact the compiler had to load ptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointer const
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.
If you are going to declare a pointer to a string and never change the pointer, then declare it as static const char * const ptr = "string";
, and the compiler can happily provide the address of the string whenever the value of ptr
is used. It does not need to actually load the contents of ptr
from memory, since it can never change and will be known to point to wherever the compiler chooses to store the string. This is then the same as static const char array = "string";
—whenever the address of the array is needed, the compiler can provide it from its knowledge of where it chose to store the array.
Furthermore, with the static
specifier, ptr
cannot be known outside the translation unit (the file being compiled), so the compiler can remove it during optimization (as long as you have not taken its address, perhaps when passing it to another routine outside the translation unit). The result should be no differences between the pointer method and the array method.
Rule of thumb: Tell the compiler as much as you know about stuff: If it will never change, mark it const
. If it is local to the current module, mark it static
. The more information the compiler has, the more it can optimize.
static
would only help for global scope or inside ofmain()
, but not any other function scope? Or should I still usestatic
inmain()
? If, e.g. I was using a string constant for a filename, and I was to call my own function to open up that file, it shouldn't matter if it's static even if that function was in another file (unless I was passing the address of it)... or am I mixing this up. I've never really usedstatic
much, to be honest.
– RastaJedi
Mar 4 at 2:25
@RastaJedi: At file scope (outside of any function),static
essentially just changes whether the thing may be known outside the current translation unit. Inside a block (any set of statements in braces in a function,main
or other),static
both says “this name is not known outside this block” and “this thing sticks around for all of program execution, not just block execution.” With aconst
object, though, the two lifetimes (static and automatic) often optimize to the same thing. (Taking addresses of things can change that, for semantic reasons, but simple uses are unaffected.)
– Eric Postpischil
Mar 4 at 2:34
So if I have astatic
string constant, and pass it to a routine in another TLU, this would still work, but the possibility of optimization goes away, is what you are getting at? Within a function, try to mark itstatic
if I don't need to change it anywhere else or pass it to any other routine, for a possibility of optimization? What about the cases of non-constant values. Just usestatic
if I need it's value to stick around when it goes out of scope or to limit to that TLU within file scope? I'm assuming there's no possibility of it being optimized in this way if it is modifiable.
– RastaJedi
Mar 4 at 2:46
Givenstatic const char * const ptr = "string";
at function level, passingptr
to a routine outside the current translation unit should have the same effect as passing"string"
orarray
, wherearray
isconst char array = "string";
. In all those cases, the compiler only needs to pass the address of the actual string, which itself may not be changed. So it should produce the same code for all of them. If you passed&ptr
outside the module, then the compiler has to create an actualptr
so it can take its address. But that is a different use case.
– Eric Postpischil
Mar 4 at 2:52
1
But gcc and icc doesn't give identical results in pointer vs array even when you make the pointer* const
. But yes overall this case is "pre-mature optimization".
– Lundin
Mar 4 at 12:33
|
show 3 more comments
From the performance perspective, this is a fairly small optimization which makes sense for low-level code that needs to run with the lowest possible latency.
However, I would argue that const char s3 = "bux";
is better from the semantic perspective, because the type of the right hand side is closer to type of the left hand side. For that reason, I think it makes sense to declare string constants with the array syntax.
1
Aren't string literals in C not technicallyconst
-qualified type? Despite being immutable. Or you just meant the array aspect of it perhaps. Also doesn't the array version have to copy an entire string?
– RastaJedi
Mar 4 at 2:09
You are correct. However, it's UB to modify the elements of a string literal, and I was referring to the array part. :)
– merlin2011
Mar 4 at 2:17
add a comment |
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%2f54975623%2fhow-should-i-define-declare-string-constants%23new-answer', 'question_page');
);
Post as a guest
Required, but never shown
3 Answers
3
active
oldest
votes
3 Answers
3
active
oldest
votes
active
oldest
votes
active
oldest
votes
Pointer and arrays are different. Defining string constants as pointers or arrays fits different purposes.
When you define a global string constant that is not subject to change, I would recommend you make it a const array:
const char product_name = "The program version 3";
Defining it as const char *product_name = "The program version 3";
actually defines 2 objects: the string constant itself, which will reside in a constant segment, and the pointer which can be changed to point to another string or set to NULL
.
Conversely, defining a string constant as a local variable would be better done as a local pointer variable of type const char *
, initialized with the address of a string constant:
int main()
const char *s1 = "world";
printf("Hello %sn", s1);
return 0;
If you define this one as an array, depending on the compiler and usage inside the function, the code will make space for the array on the stack and initialize it by copying the string constant into it, a more costly operation for long strings.
Note also that const char const *s3 = "baz";
is a redundant form of const char *s3 = "baz";
. It is different from const char * const s3 = "baz";
which defines a constant pointer to a constant array of characters.
Finally, string constants are immutable and as such should have type const char
. The C Standard purposely allows programmers to store their addresses into non const pointers as in char *s2 = "hello";
to avoid producing warnings for legacy code. In new code, it is highly advisable to always use const char *
pointers to manipulate string constants. This may force you to declare function arguments as const char *
when the function does not change the string contents. This process is known as constification and avoid subtile bugs.
Note that some functions violate this const
propagation: strchr()
does not modify the string received, declared as const char *
, but returns a char *
. It is therefore possible to store a pointer to a string constant into a plain char *
pointer this way:
char *p = strchr("Hello Worldn", 'H');
This problem is solved in C++ via overloading. C programmers must deal with this as a shortcoming. An even more annoying situation is that of strtol()
where the address of a char *
is passed and a cast is required to preserve proper constness.
Sorry,const char *const s3
is what I meant to type. Fixed it now :). So for global, using the array version won't result in a copy?
– RastaJedi
Mar 4 at 2:32
To the extent that you would get a "redundant" pointer variable in thes1
case, aren't you prone to a "redundant" array copy in theproduct_name
case (for them's the semantics) which is far worse? I've never heard this advice before tbh.
– Lightness Races in Orbit
Mar 4 at 2:35
@LightnessRacesinOrbit: in the case of a global variable, the is no copy at runtime but indeed the string constant may be duplicated in the binary file and in memory:const char *s1 = "toto", *s2 = "toto";
may initialize boths1
ands2
to the same value whereasconst char s1 = "toto", s2 = "toto";
defines 2 separate objects each with the same duplicated contents.
– chqrlie
Mar 4 at 2:38
Right, and doesn't that suggest thatconst char*
is a much superior choice?
– Lightness Races in Orbit
Mar 4 at 2:39
1
I've marked this as the accepted answer because this answers my 'how should I declare' question more directly, although the information in @EricPostpischil's answer directly comments on the information provided in my source link. Unfortunately I cannot accept two answers, but I urge all of you who are reading this answer to also view his answer. Thank you all!
– RastaJedi
Mar 4 at 3:02
|
show 4 more comments
Pointer and arrays are different. Defining string constants as pointers or arrays fits different purposes.
When you define a global string constant that is not subject to change, I would recommend you make it a const array:
const char product_name = "The program version 3";
Defining it as const char *product_name = "The program version 3";
actually defines 2 objects: the string constant itself, which will reside in a constant segment, and the pointer which can be changed to point to another string or set to NULL
.
Conversely, defining a string constant as a local variable would be better done as a local pointer variable of type const char *
, initialized with the address of a string constant:
int main()
const char *s1 = "world";
printf("Hello %sn", s1);
return 0;
If you define this one as an array, depending on the compiler and usage inside the function, the code will make space for the array on the stack and initialize it by copying the string constant into it, a more costly operation for long strings.
Note also that const char const *s3 = "baz";
is a redundant form of const char *s3 = "baz";
. It is different from const char * const s3 = "baz";
which defines a constant pointer to a constant array of characters.
Finally, string constants are immutable and as such should have type const char
. The C Standard purposely allows programmers to store their addresses into non const pointers as in char *s2 = "hello";
to avoid producing warnings for legacy code. In new code, it is highly advisable to always use const char *
pointers to manipulate string constants. This may force you to declare function arguments as const char *
when the function does not change the string contents. This process is known as constification and avoid subtile bugs.
Note that some functions violate this const
propagation: strchr()
does not modify the string received, declared as const char *
, but returns a char *
. It is therefore possible to store a pointer to a string constant into a plain char *
pointer this way:
char *p = strchr("Hello Worldn", 'H');
This problem is solved in C++ via overloading. C programmers must deal with this as a shortcoming. An even more annoying situation is that of strtol()
where the address of a char *
is passed and a cast is required to preserve proper constness.
Sorry,const char *const s3
is what I meant to type. Fixed it now :). So for global, using the array version won't result in a copy?
– RastaJedi
Mar 4 at 2:32
To the extent that you would get a "redundant" pointer variable in thes1
case, aren't you prone to a "redundant" array copy in theproduct_name
case (for them's the semantics) which is far worse? I've never heard this advice before tbh.
– Lightness Races in Orbit
Mar 4 at 2:35
@LightnessRacesinOrbit: in the case of a global variable, the is no copy at runtime but indeed the string constant may be duplicated in the binary file and in memory:const char *s1 = "toto", *s2 = "toto";
may initialize boths1
ands2
to the same value whereasconst char s1 = "toto", s2 = "toto";
defines 2 separate objects each with the same duplicated contents.
– chqrlie
Mar 4 at 2:38
Right, and doesn't that suggest thatconst char*
is a much superior choice?
– Lightness Races in Orbit
Mar 4 at 2:39
1
I've marked this as the accepted answer because this answers my 'how should I declare' question more directly, although the information in @EricPostpischil's answer directly comments on the information provided in my source link. Unfortunately I cannot accept two answers, but I urge all of you who are reading this answer to also view his answer. Thank you all!
– RastaJedi
Mar 4 at 3:02
|
show 4 more comments
Pointer and arrays are different. Defining string constants as pointers or arrays fits different purposes.
When you define a global string constant that is not subject to change, I would recommend you make it a const array:
const char product_name = "The program version 3";
Defining it as const char *product_name = "The program version 3";
actually defines 2 objects: the string constant itself, which will reside in a constant segment, and the pointer which can be changed to point to another string or set to NULL
.
Conversely, defining a string constant as a local variable would be better done as a local pointer variable of type const char *
, initialized with the address of a string constant:
int main()
const char *s1 = "world";
printf("Hello %sn", s1);
return 0;
If you define this one as an array, depending on the compiler and usage inside the function, the code will make space for the array on the stack and initialize it by copying the string constant into it, a more costly operation for long strings.
Note also that const char const *s3 = "baz";
is a redundant form of const char *s3 = "baz";
. It is different from const char * const s3 = "baz";
which defines a constant pointer to a constant array of characters.
Finally, string constants are immutable and as such should have type const char
. The C Standard purposely allows programmers to store their addresses into non const pointers as in char *s2 = "hello";
to avoid producing warnings for legacy code. In new code, it is highly advisable to always use const char *
pointers to manipulate string constants. This may force you to declare function arguments as const char *
when the function does not change the string contents. This process is known as constification and avoid subtile bugs.
Note that some functions violate this const
propagation: strchr()
does not modify the string received, declared as const char *
, but returns a char *
. It is therefore possible to store a pointer to a string constant into a plain char *
pointer this way:
char *p = strchr("Hello Worldn", 'H');
This problem is solved in C++ via overloading. C programmers must deal with this as a shortcoming. An even more annoying situation is that of strtol()
where the address of a char *
is passed and a cast is required to preserve proper constness.
Pointer and arrays are different. Defining string constants as pointers or arrays fits different purposes.
When you define a global string constant that is not subject to change, I would recommend you make it a const array:
const char product_name = "The program version 3";
Defining it as const char *product_name = "The program version 3";
actually defines 2 objects: the string constant itself, which will reside in a constant segment, and the pointer which can be changed to point to another string or set to NULL
.
Conversely, defining a string constant as a local variable would be better done as a local pointer variable of type const char *
, initialized with the address of a string constant:
int main()
const char *s1 = "world";
printf("Hello %sn", s1);
return 0;
If you define this one as an array, depending on the compiler and usage inside the function, the code will make space for the array on the stack and initialize it by copying the string constant into it, a more costly operation for long strings.
Note also that const char const *s3 = "baz";
is a redundant form of const char *s3 = "baz";
. It is different from const char * const s3 = "baz";
which defines a constant pointer to a constant array of characters.
Finally, string constants are immutable and as such should have type const char
. The C Standard purposely allows programmers to store their addresses into non const pointers as in char *s2 = "hello";
to avoid producing warnings for legacy code. In new code, it is highly advisable to always use const char *
pointers to manipulate string constants. This may force you to declare function arguments as const char *
when the function does not change the string contents. This process is known as constification and avoid subtile bugs.
Note that some functions violate this const
propagation: strchr()
does not modify the string received, declared as const char *
, but returns a char *
. It is therefore possible to store a pointer to a string constant into a plain char *
pointer this way:
char *p = strchr("Hello Worldn", 'H');
This problem is solved in C++ via overloading. C programmers must deal with this as a shortcoming. An even more annoying situation is that of strtol()
where the address of a char *
is passed and a cast is required to preserve proper constness.
edited Mar 26 at 18:31
answered Mar 4 at 2:25
chqrliechqrlie
62.3k848105
62.3k848105
Sorry,const char *const s3
is what I meant to type. Fixed it now :). So for global, using the array version won't result in a copy?
– RastaJedi
Mar 4 at 2:32
To the extent that you would get a "redundant" pointer variable in thes1
case, aren't you prone to a "redundant" array copy in theproduct_name
case (for them's the semantics) which is far worse? I've never heard this advice before tbh.
– Lightness Races in Orbit
Mar 4 at 2:35
@LightnessRacesinOrbit: in the case of a global variable, the is no copy at runtime but indeed the string constant may be duplicated in the binary file and in memory:const char *s1 = "toto", *s2 = "toto";
may initialize boths1
ands2
to the same value whereasconst char s1 = "toto", s2 = "toto";
defines 2 separate objects each with the same duplicated contents.
– chqrlie
Mar 4 at 2:38
Right, and doesn't that suggest thatconst char*
is a much superior choice?
– Lightness Races in Orbit
Mar 4 at 2:39
1
I've marked this as the accepted answer because this answers my 'how should I declare' question more directly, although the information in @EricPostpischil's answer directly comments on the information provided in my source link. Unfortunately I cannot accept two answers, but I urge all of you who are reading this answer to also view his answer. Thank you all!
– RastaJedi
Mar 4 at 3:02
|
show 4 more comments
Sorry,const char *const s3
is what I meant to type. Fixed it now :). So for global, using the array version won't result in a copy?
– RastaJedi
Mar 4 at 2:32
To the extent that you would get a "redundant" pointer variable in thes1
case, aren't you prone to a "redundant" array copy in theproduct_name
case (for them's the semantics) which is far worse? I've never heard this advice before tbh.
– Lightness Races in Orbit
Mar 4 at 2:35
@LightnessRacesinOrbit: in the case of a global variable, the is no copy at runtime but indeed the string constant may be duplicated in the binary file and in memory:const char *s1 = "toto", *s2 = "toto";
may initialize boths1
ands2
to the same value whereasconst char s1 = "toto", s2 = "toto";
defines 2 separate objects each with the same duplicated contents.
– chqrlie
Mar 4 at 2:38
Right, and doesn't that suggest thatconst char*
is a much superior choice?
– Lightness Races in Orbit
Mar 4 at 2:39
1
I've marked this as the accepted answer because this answers my 'how should I declare' question more directly, although the information in @EricPostpischil's answer directly comments on the information provided in my source link. Unfortunately I cannot accept two answers, but I urge all of you who are reading this answer to also view his answer. Thank you all!
– RastaJedi
Mar 4 at 3:02
Sorry,
const char *const s3
is what I meant to type. Fixed it now :). So for global, using the array version won't result in a copy?– RastaJedi
Mar 4 at 2:32
Sorry,
const char *const s3
is what I meant to type. Fixed it now :). So for global, using the array version won't result in a copy?– RastaJedi
Mar 4 at 2:32
To the extent that you would get a "redundant" pointer variable in the
s1
case, aren't you prone to a "redundant" array copy in the product_name
case (for them's the semantics) which is far worse? I've never heard this advice before tbh.– Lightness Races in Orbit
Mar 4 at 2:35
To the extent that you would get a "redundant" pointer variable in the
s1
case, aren't you prone to a "redundant" array copy in the product_name
case (for them's the semantics) which is far worse? I've never heard this advice before tbh.– Lightness Races in Orbit
Mar 4 at 2:35
@LightnessRacesinOrbit: in the case of a global variable, the is no copy at runtime but indeed the string constant may be duplicated in the binary file and in memory:
const char *s1 = "toto", *s2 = "toto";
may initialize both s1
and s2
to the same value whereas const char s1 = "toto", s2 = "toto";
defines 2 separate objects each with the same duplicated contents.– chqrlie
Mar 4 at 2:38
@LightnessRacesinOrbit: in the case of a global variable, the is no copy at runtime but indeed the string constant may be duplicated in the binary file and in memory:
const char *s1 = "toto", *s2 = "toto";
may initialize both s1
and s2
to the same value whereas const char s1 = "toto", s2 = "toto";
defines 2 separate objects each with the same duplicated contents.– chqrlie
Mar 4 at 2:38
Right, and doesn't that suggest that
const char*
is a much superior choice?– Lightness Races in Orbit
Mar 4 at 2:39
Right, and doesn't that suggest that
const char*
is a much superior choice?– Lightness Races in Orbit
Mar 4 at 2:39
1
1
I've marked this as the accepted answer because this answers my 'how should I declare' question more directly, although the information in @EricPostpischil's answer directly comments on the information provided in my source link. Unfortunately I cannot accept two answers, but I urge all of you who are reading this answer to also view his answer. Thank you all!
– RastaJedi
Mar 4 at 3:02
I've marked this as the accepted answer because this answers my 'how should I declare' question more directly, although the information in @EricPostpischil's answer directly comments on the information provided in my source link. Unfortunately I cannot accept two answers, but I urge all of you who are reading this answer to also view his answer. Thank you all!
– RastaJedi
Mar 4 at 3:02
|
show 4 more comments
The linked article explores a small artificial situation, and the difference demonstrated vanishes if you insert const
after *
in const char *ptr = "Lorum ipsum";
(tested in Apple LLVM 10.0.0 with clang-1000.11.45.5).
The fact the compiler had to load ptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointer const
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.
If you are going to declare a pointer to a string and never change the pointer, then declare it as static const char * const ptr = "string";
, and the compiler can happily provide the address of the string whenever the value of ptr
is used. It does not need to actually load the contents of ptr
from memory, since it can never change and will be known to point to wherever the compiler chooses to store the string. This is then the same as static const char array = "string";
—whenever the address of the array is needed, the compiler can provide it from its knowledge of where it chose to store the array.
Furthermore, with the static
specifier, ptr
cannot be known outside the translation unit (the file being compiled), so the compiler can remove it during optimization (as long as you have not taken its address, perhaps when passing it to another routine outside the translation unit). The result should be no differences between the pointer method and the array method.
Rule of thumb: Tell the compiler as much as you know about stuff: If it will never change, mark it const
. If it is local to the current module, mark it static
. The more information the compiler has, the more it can optimize.
static
would only help for global scope or inside ofmain()
, but not any other function scope? Or should I still usestatic
inmain()
? If, e.g. I was using a string constant for a filename, and I was to call my own function to open up that file, it shouldn't matter if it's static even if that function was in another file (unless I was passing the address of it)... or am I mixing this up. I've never really usedstatic
much, to be honest.
– RastaJedi
Mar 4 at 2:25
@RastaJedi: At file scope (outside of any function),static
essentially just changes whether the thing may be known outside the current translation unit. Inside a block (any set of statements in braces in a function,main
or other),static
both says “this name is not known outside this block” and “this thing sticks around for all of program execution, not just block execution.” With aconst
object, though, the two lifetimes (static and automatic) often optimize to the same thing. (Taking addresses of things can change that, for semantic reasons, but simple uses are unaffected.)
– Eric Postpischil
Mar 4 at 2:34
So if I have astatic
string constant, and pass it to a routine in another TLU, this would still work, but the possibility of optimization goes away, is what you are getting at? Within a function, try to mark itstatic
if I don't need to change it anywhere else or pass it to any other routine, for a possibility of optimization? What about the cases of non-constant values. Just usestatic
if I need it's value to stick around when it goes out of scope or to limit to that TLU within file scope? I'm assuming there's no possibility of it being optimized in this way if it is modifiable.
– RastaJedi
Mar 4 at 2:46
Givenstatic const char * const ptr = "string";
at function level, passingptr
to a routine outside the current translation unit should have the same effect as passing"string"
orarray
, wherearray
isconst char array = "string";
. In all those cases, the compiler only needs to pass the address of the actual string, which itself may not be changed. So it should produce the same code for all of them. If you passed&ptr
outside the module, then the compiler has to create an actualptr
so it can take its address. But that is a different use case.
– Eric Postpischil
Mar 4 at 2:52
1
But gcc and icc doesn't give identical results in pointer vs array even when you make the pointer* const
. But yes overall this case is "pre-mature optimization".
– Lundin
Mar 4 at 12:33
|
show 3 more comments
The linked article explores a small artificial situation, and the difference demonstrated vanishes if you insert const
after *
in const char *ptr = "Lorum ipsum";
(tested in Apple LLVM 10.0.0 with clang-1000.11.45.5).
The fact the compiler had to load ptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointer const
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.
If you are going to declare a pointer to a string and never change the pointer, then declare it as static const char * const ptr = "string";
, and the compiler can happily provide the address of the string whenever the value of ptr
is used. It does not need to actually load the contents of ptr
from memory, since it can never change and will be known to point to wherever the compiler chooses to store the string. This is then the same as static const char array = "string";
—whenever the address of the array is needed, the compiler can provide it from its knowledge of where it chose to store the array.
Furthermore, with the static
specifier, ptr
cannot be known outside the translation unit (the file being compiled), so the compiler can remove it during optimization (as long as you have not taken its address, perhaps when passing it to another routine outside the translation unit). The result should be no differences between the pointer method and the array method.
Rule of thumb: Tell the compiler as much as you know about stuff: If it will never change, mark it const
. If it is local to the current module, mark it static
. The more information the compiler has, the more it can optimize.
static
would only help for global scope or inside ofmain()
, but not any other function scope? Or should I still usestatic
inmain()
? If, e.g. I was using a string constant for a filename, and I was to call my own function to open up that file, it shouldn't matter if it's static even if that function was in another file (unless I was passing the address of it)... or am I mixing this up. I've never really usedstatic
much, to be honest.
– RastaJedi
Mar 4 at 2:25
@RastaJedi: At file scope (outside of any function),static
essentially just changes whether the thing may be known outside the current translation unit. Inside a block (any set of statements in braces in a function,main
or other),static
both says “this name is not known outside this block” and “this thing sticks around for all of program execution, not just block execution.” With aconst
object, though, the two lifetimes (static and automatic) often optimize to the same thing. (Taking addresses of things can change that, for semantic reasons, but simple uses are unaffected.)
– Eric Postpischil
Mar 4 at 2:34
So if I have astatic
string constant, and pass it to a routine in another TLU, this would still work, but the possibility of optimization goes away, is what you are getting at? Within a function, try to mark itstatic
if I don't need to change it anywhere else or pass it to any other routine, for a possibility of optimization? What about the cases of non-constant values. Just usestatic
if I need it's value to stick around when it goes out of scope or to limit to that TLU within file scope? I'm assuming there's no possibility of it being optimized in this way if it is modifiable.
– RastaJedi
Mar 4 at 2:46
Givenstatic const char * const ptr = "string";
at function level, passingptr
to a routine outside the current translation unit should have the same effect as passing"string"
orarray
, wherearray
isconst char array = "string";
. In all those cases, the compiler only needs to pass the address of the actual string, which itself may not be changed. So it should produce the same code for all of them. If you passed&ptr
outside the module, then the compiler has to create an actualptr
so it can take its address. But that is a different use case.
– Eric Postpischil
Mar 4 at 2:52
1
But gcc and icc doesn't give identical results in pointer vs array even when you make the pointer* const
. But yes overall this case is "pre-mature optimization".
– Lundin
Mar 4 at 12:33
|
show 3 more comments
The linked article explores a small artificial situation, and the difference demonstrated vanishes if you insert const
after *
in const char *ptr = "Lorum ipsum";
(tested in Apple LLVM 10.0.0 with clang-1000.11.45.5).
The fact the compiler had to load ptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointer const
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.
If you are going to declare a pointer to a string and never change the pointer, then declare it as static const char * const ptr = "string";
, and the compiler can happily provide the address of the string whenever the value of ptr
is used. It does not need to actually load the contents of ptr
from memory, since it can never change and will be known to point to wherever the compiler chooses to store the string. This is then the same as static const char array = "string";
—whenever the address of the array is needed, the compiler can provide it from its knowledge of where it chose to store the array.
Furthermore, with the static
specifier, ptr
cannot be known outside the translation unit (the file being compiled), so the compiler can remove it during optimization (as long as you have not taken its address, perhaps when passing it to another routine outside the translation unit). The result should be no differences between the pointer method and the array method.
Rule of thumb: Tell the compiler as much as you know about stuff: If it will never change, mark it const
. If it is local to the current module, mark it static
. The more information the compiler has, the more it can optimize.
The linked article explores a small artificial situation, and the difference demonstrated vanishes if you insert const
after *
in const char *ptr = "Lorum ipsum";
(tested in Apple LLVM 10.0.0 with clang-1000.11.45.5).
The fact the compiler had to load ptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointer const
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.
If you are going to declare a pointer to a string and never change the pointer, then declare it as static const char * const ptr = "string";
, and the compiler can happily provide the address of the string whenever the value of ptr
is used. It does not need to actually load the contents of ptr
from memory, since it can never change and will be known to point to wherever the compiler chooses to store the string. This is then the same as static const char array = "string";
—whenever the address of the array is needed, the compiler can provide it from its knowledge of where it chose to store the array.
Furthermore, with the static
specifier, ptr
cannot be known outside the translation unit (the file being compiled), so the compiler can remove it during optimization (as long as you have not taken its address, perhaps when passing it to another routine outside the translation unit). The result should be no differences between the pointer method and the array method.
Rule of thumb: Tell the compiler as much as you know about stuff: If it will never change, mark it const
. If it is local to the current module, mark it static
. The more information the compiler has, the more it can optimize.
answered Mar 4 at 2:18
Eric PostpischilEric Postpischil
79.5k887168
79.5k887168
static
would only help for global scope or inside ofmain()
, but not any other function scope? Or should I still usestatic
inmain()
? If, e.g. I was using a string constant for a filename, and I was to call my own function to open up that file, it shouldn't matter if it's static even if that function was in another file (unless I was passing the address of it)... or am I mixing this up. I've never really usedstatic
much, to be honest.
– RastaJedi
Mar 4 at 2:25
@RastaJedi: At file scope (outside of any function),static
essentially just changes whether the thing may be known outside the current translation unit. Inside a block (any set of statements in braces in a function,main
or other),static
both says “this name is not known outside this block” and “this thing sticks around for all of program execution, not just block execution.” With aconst
object, though, the two lifetimes (static and automatic) often optimize to the same thing. (Taking addresses of things can change that, for semantic reasons, but simple uses are unaffected.)
– Eric Postpischil
Mar 4 at 2:34
So if I have astatic
string constant, and pass it to a routine in another TLU, this would still work, but the possibility of optimization goes away, is what you are getting at? Within a function, try to mark itstatic
if I don't need to change it anywhere else or pass it to any other routine, for a possibility of optimization? What about the cases of non-constant values. Just usestatic
if I need it's value to stick around when it goes out of scope or to limit to that TLU within file scope? I'm assuming there's no possibility of it being optimized in this way if it is modifiable.
– RastaJedi
Mar 4 at 2:46
Givenstatic const char * const ptr = "string";
at function level, passingptr
to a routine outside the current translation unit should have the same effect as passing"string"
orarray
, wherearray
isconst char array = "string";
. In all those cases, the compiler only needs to pass the address of the actual string, which itself may not be changed. So it should produce the same code for all of them. If you passed&ptr
outside the module, then the compiler has to create an actualptr
so it can take its address. But that is a different use case.
– Eric Postpischil
Mar 4 at 2:52
1
But gcc and icc doesn't give identical results in pointer vs array even when you make the pointer* const
. But yes overall this case is "pre-mature optimization".
– Lundin
Mar 4 at 12:33
|
show 3 more comments
static
would only help for global scope or inside ofmain()
, but not any other function scope? Or should I still usestatic
inmain()
? If, e.g. I was using a string constant for a filename, and I was to call my own function to open up that file, it shouldn't matter if it's static even if that function was in another file (unless I was passing the address of it)... or am I mixing this up. I've never really usedstatic
much, to be honest.
– RastaJedi
Mar 4 at 2:25
@RastaJedi: At file scope (outside of any function),static
essentially just changes whether the thing may be known outside the current translation unit. Inside a block (any set of statements in braces in a function,main
or other),static
both says “this name is not known outside this block” and “this thing sticks around for all of program execution, not just block execution.” With aconst
object, though, the two lifetimes (static and automatic) often optimize to the same thing. (Taking addresses of things can change that, for semantic reasons, but simple uses are unaffected.)
– Eric Postpischil
Mar 4 at 2:34
So if I have astatic
string constant, and pass it to a routine in another TLU, this would still work, but the possibility of optimization goes away, is what you are getting at? Within a function, try to mark itstatic
if I don't need to change it anywhere else or pass it to any other routine, for a possibility of optimization? What about the cases of non-constant values. Just usestatic
if I need it's value to stick around when it goes out of scope or to limit to that TLU within file scope? I'm assuming there's no possibility of it being optimized in this way if it is modifiable.
– RastaJedi
Mar 4 at 2:46
Givenstatic const char * const ptr = "string";
at function level, passingptr
to a routine outside the current translation unit should have the same effect as passing"string"
orarray
, wherearray
isconst char array = "string";
. In all those cases, the compiler only needs to pass the address of the actual string, which itself may not be changed. So it should produce the same code for all of them. If you passed&ptr
outside the module, then the compiler has to create an actualptr
so it can take its address. But that is a different use case.
– Eric Postpischil
Mar 4 at 2:52
1
But gcc and icc doesn't give identical results in pointer vs array even when you make the pointer* const
. But yes overall this case is "pre-mature optimization".
– Lundin
Mar 4 at 12:33
static
would only help for global scope or inside of main()
, but not any other function scope? Or should I still use static
in main()
? If, e.g. I was using a string constant for a filename, and I was to call my own function to open up that file, it shouldn't matter if it's static even if that function was in another file (unless I was passing the address of it)... or am I mixing this up. I've never really used static
much, to be honest.– RastaJedi
Mar 4 at 2:25
static
would only help for global scope or inside of main()
, but not any other function scope? Or should I still use static
in main()
? If, e.g. I was using a string constant for a filename, and I was to call my own function to open up that file, it shouldn't matter if it's static even if that function was in another file (unless I was passing the address of it)... or am I mixing this up. I've never really used static
much, to be honest.– RastaJedi
Mar 4 at 2:25
@RastaJedi: At file scope (outside of any function),
static
essentially just changes whether the thing may be known outside the current translation unit. Inside a block (any set of statements in braces in a function, main
or other), static
both says “this name is not known outside this block” and “this thing sticks around for all of program execution, not just block execution.” With a const
object, though, the two lifetimes (static and automatic) often optimize to the same thing. (Taking addresses of things can change that, for semantic reasons, but simple uses are unaffected.)– Eric Postpischil
Mar 4 at 2:34
@RastaJedi: At file scope (outside of any function),
static
essentially just changes whether the thing may be known outside the current translation unit. Inside a block (any set of statements in braces in a function, main
or other), static
both says “this name is not known outside this block” and “this thing sticks around for all of program execution, not just block execution.” With a const
object, though, the two lifetimes (static and automatic) often optimize to the same thing. (Taking addresses of things can change that, for semantic reasons, but simple uses are unaffected.)– Eric Postpischil
Mar 4 at 2:34
So if I have a
static
string constant, and pass it to a routine in another TLU, this would still work, but the possibility of optimization goes away, is what you are getting at? Within a function, try to mark it static
if I don't need to change it anywhere else or pass it to any other routine, for a possibility of optimization? What about the cases of non-constant values. Just use static
if I need it's value to stick around when it goes out of scope or to limit to that TLU within file scope? I'm assuming there's no possibility of it being optimized in this way if it is modifiable.– RastaJedi
Mar 4 at 2:46
So if I have a
static
string constant, and pass it to a routine in another TLU, this would still work, but the possibility of optimization goes away, is what you are getting at? Within a function, try to mark it static
if I don't need to change it anywhere else or pass it to any other routine, for a possibility of optimization? What about the cases of non-constant values. Just use static
if I need it's value to stick around when it goes out of scope or to limit to that TLU within file scope? I'm assuming there's no possibility of it being optimized in this way if it is modifiable.– RastaJedi
Mar 4 at 2:46
Given
static const char * const ptr = "string";
at function level, passing ptr
to a routine outside the current translation unit should have the same effect as passing "string"
or array
, where array
is const char array = "string";
. In all those cases, the compiler only needs to pass the address of the actual string, which itself may not be changed. So it should produce the same code for all of them. If you passed &ptr
outside the module, then the compiler has to create an actual ptr
so it can take its address. But that is a different use case.– Eric Postpischil
Mar 4 at 2:52
Given
static const char * const ptr = "string";
at function level, passing ptr
to a routine outside the current translation unit should have the same effect as passing "string"
or array
, where array
is const char array = "string";
. In all those cases, the compiler only needs to pass the address of the actual string, which itself may not be changed. So it should produce the same code for all of them. If you passed &ptr
outside the module, then the compiler has to create an actual ptr
so it can take its address. But that is a different use case.– Eric Postpischil
Mar 4 at 2:52
1
1
But gcc and icc doesn't give identical results in pointer vs array even when you make the pointer
* const
. But yes overall this case is "pre-mature optimization".– Lundin
Mar 4 at 12:33
But gcc and icc doesn't give identical results in pointer vs array even when you make the pointer
* const
. But yes overall this case is "pre-mature optimization".– Lundin
Mar 4 at 12:33
|
show 3 more comments
From the performance perspective, this is a fairly small optimization which makes sense for low-level code that needs to run with the lowest possible latency.
However, I would argue that const char s3 = "bux";
is better from the semantic perspective, because the type of the right hand side is closer to type of the left hand side. For that reason, I think it makes sense to declare string constants with the array syntax.
1
Aren't string literals in C not technicallyconst
-qualified type? Despite being immutable. Or you just meant the array aspect of it perhaps. Also doesn't the array version have to copy an entire string?
– RastaJedi
Mar 4 at 2:09
You are correct. However, it's UB to modify the elements of a string literal, and I was referring to the array part. :)
– merlin2011
Mar 4 at 2:17
add a comment |
From the performance perspective, this is a fairly small optimization which makes sense for low-level code that needs to run with the lowest possible latency.
However, I would argue that const char s3 = "bux";
is better from the semantic perspective, because the type of the right hand side is closer to type of the left hand side. For that reason, I think it makes sense to declare string constants with the array syntax.
1
Aren't string literals in C not technicallyconst
-qualified type? Despite being immutable. Or you just meant the array aspect of it perhaps. Also doesn't the array version have to copy an entire string?
– RastaJedi
Mar 4 at 2:09
You are correct. However, it's UB to modify the elements of a string literal, and I was referring to the array part. :)
– merlin2011
Mar 4 at 2:17
add a comment |
From the performance perspective, this is a fairly small optimization which makes sense for low-level code that needs to run with the lowest possible latency.
However, I would argue that const char s3 = "bux";
is better from the semantic perspective, because the type of the right hand side is closer to type of the left hand side. For that reason, I think it makes sense to declare string constants with the array syntax.
From the performance perspective, this is a fairly small optimization which makes sense for low-level code that needs to run with the lowest possible latency.
However, I would argue that const char s3 = "bux";
is better from the semantic perspective, because the type of the right hand side is closer to type of the left hand side. For that reason, I think it makes sense to declare string constants with the array syntax.
edited Mar 4 at 2:18
answered Mar 4 at 2:03
merlin2011merlin2011
44.4k26121221
44.4k26121221
1
Aren't string literals in C not technicallyconst
-qualified type? Despite being immutable. Or you just meant the array aspect of it perhaps. Also doesn't the array version have to copy an entire string?
– RastaJedi
Mar 4 at 2:09
You are correct. However, it's UB to modify the elements of a string literal, and I was referring to the array part. :)
– merlin2011
Mar 4 at 2:17
add a comment |
1
Aren't string literals in C not technicallyconst
-qualified type? Despite being immutable. Or you just meant the array aspect of it perhaps. Also doesn't the array version have to copy an entire string?
– RastaJedi
Mar 4 at 2:09
You are correct. However, it's UB to modify the elements of a string literal, and I was referring to the array part. :)
– merlin2011
Mar 4 at 2:17
1
1
Aren't string literals in C not technically
const
-qualified type? Despite being immutable. Or you just meant the array aspect of it perhaps. Also doesn't the array version have to copy an entire string?– RastaJedi
Mar 4 at 2:09
Aren't string literals in C not technically
const
-qualified type? Despite being immutable. Or you just meant the array aspect of it perhaps. Also doesn't the array version have to copy an entire string?– RastaJedi
Mar 4 at 2:09
You are correct. However, it's UB to modify the elements of a string literal, and I was referring to the array part. :)
– merlin2011
Mar 4 at 2:17
You are correct. However, it's UB to modify the elements of a string literal, and I was referring to the array part. :)
– merlin2011
Mar 4 at 2:17
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%2f54975623%2fhow-should-i-define-declare-string-constants%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
1
Interesting.. The author is correct - "arrays" ARE different from "pointers". And I would have THOUGHT that the pointer syntax (e.g.
const char *s = "bar";
) was generally "preferred". I'm surprised with his conclusions that "array syntax" is actually more efficient - with different compilers, and on different platforms.– paulsm4
Mar 4 at 1:52
Indeed. I always used
const char *s = "bar";
where I could. I never really thought to use a const-char array. I've been trying to find a solid answer for 2 days so I figured I had to ask here :P. I realize that I can usesizeof
with the array version, but that isn't really too important at least in my current case. I'm wondering, with this author's considerations, what the general approach should be.– RastaJedi
Mar 4 at 1:54
1
Seems like a micro-optimization to me.
– dbush
Mar 4 at 1:58
I had another pro-array version link I was reading, that was talking about the overhead of using the pointer version. I can't seem to find it right now but I'll post back if I do. And @dbush, I'm sure, but I don't know if I have OCD or what, but I get real picky about real mundane stuff haha.
– RastaJedi
Mar 4 at 2:01
1
In Apple LLVM 10,0.0 with clang-1000.11.45.5, the difference vanishes if you insert
const
after*
inconst char *ptr = "Lorum ipsum";
. The fact the compiler had to loadptr
arose entirely from the fact it could be changed in some other module not visible to the compiler. Making the pointerconst
eliminates that, and the compiler can prepare the address of the string directly, without loading the pointer.– Eric Postpischil
Mar 4 at 2:10