Why am I able to change the contents of const char *ptr?
I passed a pointer ptr
to a function whose prototype takes it as const
.
foo( const char *str );
Which according to my understanding means that it will not be able to change the contents of ptr
passed. Like in the case of foo( const int i )
. If foo()
tries to chnage the value of i
, compiler gives error.
ptr
easily.
Please have a look at the following code
foo( const char *str )
{
strcpy( str, "ABC" ) ;
printf( "%s(): %s\n" , __func__ , str ) ;
}
main()
{
char ptr[ ] = "Its just to fill the space" ;
printf( "%s(): %s\n" , __func__ , ptr ) ;
foo( const ptr ) ;
printf( "%s(): %s\n" , __func__ , ptr ) ;
return;
}
On compilation, I only get a warning, no error:
warning: passing argument 1 of ‘strcpy’ discards qualifiers from pointer target type
and when I run it, I get an output instead of Segmentation Fault
main(): Its just to fill the space
foo(): ABC main(): ABC
Now, my questions is
1- What doesconst char *str
in prototype actually means?
Does this mean that function cannot change the contents of str
? If that is so then how come the above program changes the value?
2- How can I make sure that the contents of the pointer I have passed will not be changed?
From "contents of the pointer" in the above stated question, I mean "contents of the memory pointed at by the pointer", not "address contained in the pointer".
Edit
Most replies say that this is because of strcpy
and C implicit type conversion. But now I tried this
foo( const char *str )
{
str = "Tim" ;
// strcpy( str, "ABC" ) ;
printf( "%s(): %s\n" , __func__ , str ) ;
}
This time the output is, with no warning from compiler
main(): Its just to fill the space
foo(): Tim main(): Its just to fill the space
So apparently, memory pointed to by str
is changed to the memory location containing "Tim"
while its in foo()
. Although I didn't use strcpy()
this time.
const
supposed to stop this? or my understanding is wrong?
To me it seems that eve开发者_开发问答n with const
, I can change the memory reference and the contents of memory reference too. Then what is the use?
Can you give me an example where complier will give me error that I am trying to change a const pointer?
Thanks to all of you for your time and effort.
Your understanding is correct, const char*
is a contract that means you can't change memory through this particular pointer.
The problem is that C is very lax with type conversions. strcpy
takes a pointer to non-const char, and it is implicitly converted from const char*
to char*
(as compiler helpfully tells you). You could as easily pass an integer instead of pointer. As a result, your function can't change content pointed by ptr
, but strcpy
can, because it sees a non-const pointer. You don't get a crash, because in your case, the pointer points to an actual buffer of sufficient size, not a read-only string literal.
To avoid this, look for compiler warnings, or compile, for example, with -Wall -Werror
(if you are using gcc).
This behaviour is specific to C. C++, for example, does not allow that, and requires an explicit cast (C-style cast or a const_cast
) to strip const
qualifier, as you would reasonably expect.
Answer to the extended question
You are assigning a string literal into a non-const char, which, unfortunately, is legal in C and even C++! It is implicitly converted to char*
, even though writing through this pointer will now result in undefined behaviour. It is a deprecated feature, and only C++0x so far does not allow this to happen.
With that said, In order to stop changing the pointer itself, you have to declare it as const pointer to char (char *const
). Or, if you want to make it that both the contents pointed by it and the pointer itself don't change, use a const pointer to const char (const char * const
).
Examples:
void foo (
char *a,
const char *b,
char *const c,
const char *const d)
{
char buf[10];
a = buf; /* OK, changing the pointer */
*a = 'a'; /* OK, changing contents pointed by pointer */
b = buf; /* OK, changing the pointer */
*b = 'b'; /* error, changing contents pointed by pointer */
c = buf; /* error, changing pointer */
*c = 'c'; /* OK, changing contents pointed by pointer */
d = buf; /* error, changing pointer */
*d = 'd'; /* error, changing contents pointed by pointer */
}
For all error lines GCC gives me "error: assignment of read-only location".
"const" is really a compile-time thing, so don't expect a segfault unless the pointer points to some invalid memory. When using const pointers in a way that could potentially alter whatever they point to (in this case passing it to strcpy which accepts non-const), will generate a warning.
1- What does const char *str in prototype actually means? Does this mean that function cannot change the contents of str?
Yes! This means we cannot change the contents of something(either a char
or an array of chars
) pointed to by str.
If that is so then how come the above program changes the value?
Thats because strcpy()
's prototype is char * strcpy ( char * destination, const char * source );
In your code there is an implicit conversion from const char*
to char*
type because strcpy()
requires its first argument to be of the type char*
.
Technically speaking your code is incorrect rather dangerous. If you try the same code in C++ you'll surely get an error. C++ doesn't allow such implicit conversions but C does.
IIRC the const
means that the value of the parameter may not be changed. I your case, the value is the address the pointer points to. strcpy
doesn't change the address the pointer points to, but the memory the pointer points to.
Using const
here makes sure that the memory reference (address) isn't changed. The memory referenced may be changed, however. This is what's happening here. Assigning a new address to the pointer would result in an error.
SIDE NOTE
I'd consider your foo
method insecure. You'd better pass the maximum length of str
as well and perform a length check, otherwise you'll be open for buffer overflows.
EDIT
I took the following from this site:
The
const char *Str
tells the compiler that the DATA the pointer points too is const. This means,Str
can be changed within Func, but*Str
cannot. As a copy of the pointer is passed to Func, any changes made toStr
are not seen by main....
const char*
is the same as char const*
and not char* const
. So this means a pointer to something you can't change.
Elaborating after your edit. The first form inhibits the data to be changed (unless you cast implicitly or explicitly) the second inhibits the pointer itself to be changed.
What you do in your edited version is to change the pointer. This is legal here. If you'd inhibit both you'd have to write char const* const
.
精彩评论