constness and pointers to pointers

by

The reason char ** -> const char** is a “dangerous” conversion is the following code:

const char immutable[] = "don't modify this";

void get_immutable_str(const char **p) {
    *p = immutable;
    return;
}

int main() {
    char *ptr;
    get_immutable_str(&ptr); // <--- here is the dangerous conversion
    ptr[0] = 0;
}

The above code attempts to modify a non-modifiable object (the global array of const char), which is undefined behavior. There is no other candidate in this code for something to define as “bad”, so const-safety dictates that the pointer conversion is bad.

C does not forbid the conversion, but gcc warns you that it’s bad. FYI, C++ does forbid the conversion, it has stricter const-safety than C.

I would have used a string literal for the example, except that string literals in C are “dangerous” to begin with — you’re not allowed to modify them but they have type array-of-char rather than array-of-const char. This is for historical reasons.

I thought a pointer to an address can always be casted to a const pointer

A pointer-to-non-const-T can be converted to a pointer-to-const-T. char ** -> const char** isn’t an example of that pattern, because if T is char * then const T is char * const, not const char * (at this point it’s probably worthwhile not writing the const on the left any more: write char const * and you won’t expect it to be the same as T const where T is char *).

You can safely convert char ** to char * const *, and (for reasons that require a little more than just the simple rule) you can safely convert char ** to char const * const *.

More Related Contents:

  1. What is the difference between char * const and const char *?
  2. Why can’t I convert ‘char**’ to a ‘const char* const*’ in C?
  3. constant pointer vs pointer on a constant value [duplicate]
  4. Constant pointer vs Pointer to constant [duplicate]
  5. In C, can a const variable be modified via a pointer?
  6. Why can I change a local const variable through pointer casts but not a global one in C?
  7. Difference between char* and const char*?
  8. const usage with pointers in C
  9. Confusion regarding modification of const variable using pointers
  10. Why can I change the value of a const char* variable?
  11. C pointer to array/array of pointers disambiguation
  12. How do pointer-to-pointers work in C? (and when might you use them?)
  13. Pointers in C: when to use the ampersand and the asterisk?
  14. Is NULL always zero in C?
  15. What does the ‘array name’ mean in case of array of char pointers?
  16. What exactly is meant by “de-referencing a NULL pointer”?
  17. Why do I need to use type** to point to type*?
  18. Meaning of “referencing” and “dereferencing” in C
  19. Parameter Passing in C – Pointers, Addresses, Aliases
  20. Does C99 guarantee that arrays are contiguous?
  21. How is the result struct of localtime allocated in C?
  22. What does getting the address of an array variable mean?
  23. Why can´t we assign a new string to an char array, but to a pointer?
  24. C pointers and arrays/ ‘sizeof’ operator [duplicate]
  25. Array of size 0 at the end of struct [duplicate]
  26. Dereference void pointer
  27. Printing pointers in C
  28. lvalue required as increment operand
  29. pointer default value .?
  30. Is it possible to store the address of a label in a variable and use goto to jump to it?

Leave a Comment