OS : Win XP
Env: VC++ 2008
void foo_ptr(const char * & ptr) //reference to a pointer to a constant character
{
return;
}
//allowed
void foo_char(const char & p_Char) //reference to a constant character
{
return;
}
int main()
{
char ch = 'd';
char *ptr = "anuh";
foo_char(ch);
! //foo_ptr(ptr); //NOT ALLOWED syntax error, vc++, 2008
return 0;
}
I am interested in knowing the reason of syntax error when we call foo_ptr. When foo_char is allowed why not foo_ptr.
just to keep updated the same question has been asked http://stackoverflow.com/questions/7850843/c-need-reason-for-error-cannot-convert-parameter-1-from-char-to-const
Env: VC++ 2008
void foo_ptr(const char * & ptr) //reference to a pointer to a constant character
{
return;
}
//allowed
void foo_char(const char & p_Char) //reference to a constant character
{
return;
}
int main()
{
char ch = 'd';
char *ptr = "anuh";
foo_char(ch);
! //foo_ptr(ptr); //NOT ALLOWED syntax error, vc++, 2008
return 0;
}
I am interested in knowing the reason of syntax error when we call foo_ptr. When foo_char is allowed why not foo_ptr.
just to keep updated the same question has been asked http://stackoverflow.com/questions/7850843/c-need-reason-for-error-cannot-convert-parameter-1-from-char-to-const
Satisfied with answer given by James in Stackoverflow
ReplyDelete...........................................
Revised with more examples: Eric Z provides the correct answer. By passing a non const pointer (char *) as reference parameter of a const pointer (foo_ptr(const char * ¶m)) you risk returning a const pointer type (const char *) and the compiler won't allow you to do that.
Here's Eric's example of that, but I tried to explain how things would go wrong if it compiled by adding additional comments and code:
void foo_ptr(const char * & ptr)
{
//Valid assignment, and the char * is now pointing to a const
//array of "readonlystring"
ptr = "readonlystring";
}
...
//inside main
char *ptr = malloc(10*sizeof(char));
//See you can edit ptr, it's not const.
ptr[0] = 'a';
ptr[1] = 'b';
//this should not compile, but lets assume it did..
foo_ptr(ptr);
//Oh no, now ptr[0] is 'r' inside of constant memory,
//but now since ptr isn't declared const here I can overwrite it!
//But luckily most (all?) compilers actually fail to compile this code.
ptr[0] = 'b';
But if you change your paremeter so you can't affect the value that the pointer points to then the compiler will let you past in a non-const because there is no chance a const valued pointer is returned.
By placing the keyword const AFTER the * in your parameter deceleration you do just that. That means change:
void foo_ptr(const char * & ptr)
to
void foo_ptr(const char * const & ptr)
and your compiler will be happy.
Now you would not be able to do something like ptr = "readonlystring" in the above example because that would never compile now. Based on your question that should be OK because you would not be able to do the assignment to a const char & in your original example.