Need a better understanding of these operations with const pointers in C

Question

As a follow up to this question: How do you specify variables to be final in C?, I've been playing around with const variables. In particular, I've written and compiled the following program:

#include<stdio.h>

int main(void) {
    const int i = 5;
    int* i_ptr = &i;

    *i_ptr = *i_ptr + 1;      // (1)

    printf("%d %d\n", *i_ptr, i); 

    int j = 10;
    const int* j_ptr = &j;
    
    j_ptr = i_ptr;       // (2)
    
    printf("%d %d\n", *j_ptr, j);

    return 0;
}

I'm working with the following gcc compiler:

$ gcc --version 
Apple LLVM version 8.1.0 (clang-802.0.42) 
Target: x86_64-apple-darwin16.5.0 
Thread model: posix

In the code listing, I've marked two lines of code that behave differently than I'd expect:

1. (1) I would expect the compiler to spit at me for trying to modify the const variable i that i_ptr but to my surprise it does not.
2. (2) I would expect another error to be generated here because j_ptr has just been declared const and now modifying it is perfectly okay.

Further more, here is the output I get:

6 5
6 10

What's surprising here is that, in the first line out output, i_ptr and i do not have the same values here. What gives? I certainly didn't call malloc and assign i_ptr to new memory.

So how is it pointing to something besides i?

What's even more puzzling is that, if I replace line (2) with this:

*j_ptr = *j_ptr + 1; 

I get

error: read-only variable is not assignable

I'd expect that, since j_ptr is pointing to non-const variable j, it should increment j. But that doesn't happen.

I'd really appreciate if someone could explain my observations, as I can't seem to come up with any reasons for why these const pointers should behave this counter-intuitively.

Answer 1

Quoting C11, chapter §6.7.3

If an attempt is made to modify an object defined with a const-qualified type through use of an lvalue with non-const-qualified type, the behavior is undefined. [...]

So, the syntax is not forbidden as per the standard, just doing so causes undefined behavior. Any compiler, with sufficient level of warnings enabled should scream at the assignments which attempts to discards the const qualifier.

Secondly, in case of const int* j_ptr = &j;, the const is applicable for the pointed type, not the value of the variable. Thus, you can change j_ptr, but not *j_ptr.

Answer 2

You can modify const variable through pointer but this is undefined behaviour.

This should be an error:

const int i = 5;
int* i_ptr = &i;  //This is error!

While this shouldn't be:

const int i = 5;
const int* i_ptr = &i;  //This is ok
*i_ptr = 4;    //This is error, you cannot write to pointer if it is expressed as const

In second type, it means that you cannot write via i_ptr variable.

If const int a = 5 means that it is constant variable and can't be modified, const int* a_ptr means that variable points to some constant value but variable a_ptr itself is not constant and can be modified.

---

In some functions, you may see this function structure:

void funcname(const int* arr, size_t size) {

}

Please focus on const part of function parameter. This const means for this function that code can not be modified via arr pointer, but only read can be done.

Example function to read data from array:

void funcname(const int* arr, size_t size) {
    while (size--) {
        a = *arr;        //You can read
        *arr = *arr * 2; //You cannot update it! 
        arr++            //You can do that as you modify where pointer points not value on location where it points.
    }
}

---

But if you want to prevent that also pointer where it points can't be modified, you can do this using below function. Check first parameter with double const.

void funcname(const int* const arr, size_t size) {
    while (size--) {
        a = *arr;        //You can read
        *arr = *arr * 2; //You cannot update it! 
        arr++            //Error! You cannot even increase pointer because of second const keyword in parameter
    }
}

Please check this too: http://publications.gbdirect.co.uk/c_book/chapter8/const_and_volatile.html

Answer 3

Also note the place you put const to.

If you do:

int i = 0;
const int * ptr_to_const_value = &i;
int * const const_ptr = &i;
ptr_to_const_value = &j // this is ok
const_ptr = &j; // this does not compile

To ptr_to_const_value you can assign pointer at any time, but you cannot modify value this pointer points to.

On the other hand, const_ptr cannot be reassigned, but you can modify the value it points to.