Question

Here’s a code snippet that hopefully conveys what I’m trying to do:

void updatePointer(const int*& i)
{
  i++;
}

int main() {


  int array[5];
  int* arrayPtr = array;

  updatePointer(arrayPtr );
  return 0;
}

This gives compiler error:

prog.cpp: In function ‘int main()’:
prog.cpp:16: error: invalid initialization of reference of type ‘const int*&’ from
expression of type ‘int*’
prog.cpp:5: error: in passing argument 1 of ‘void updatePointer(const int*&)’

Answer 1

Supposing that you could do it, you could write the following:

const int c = 0;

void updatePointer(const int* &i) {
    i = &c;
}

int main() {
    int *ptr;
    updatePointer(ptr);
    *ptr = 1; // attempt to modify the const object c, undefined behavior
}

The purpose of const is to ensure that user code cannot attempt to modify a const object unless it contains a const-cast (or equivalent). So the compiler has to refuse this code. Forbidding a const int*& from binding to an int* is the only place in the code above that’s reasonable for the compiler to refuse: every other line is fine.

It’s the same reason you can’t implicitly convert int** to const int **.

Aside from the motivation in terms of const-safety, you can think if it in terms of int* being a different type from const int*, that just so happens to be convertible to it. Likewise, you can convert int to double, but a double& can’t bind to an int lvalue. That’s not the full reason, because actually int* and const int* have the same size and representation, whereas int and double don’t. So there could be a special-case to allow it if not for the fact that it would break the const system.

The reason that C++ has both const and non-const overloads for strchr is related to this issue: your function updatePointer modifies its input rather than returning the updated value, but the principle is similar. The C-style single strchr allows you to “launder” a pointer-to-const into a pointer-to-non-const without a cast, and it’s a hole in the const system. C++ (a) has overloading and (b) has a stricter type system than C, so it closes that hole.

If you want your real function updatePointer to work like strchr — examine the data pointed to and compute a new value for the pointer, then you’re in the same situation that strchr is. That’s regardless of what it does with the new value (return it in the case of strchr, write it back in the case of updatePointer), because the issue is that you want the new pointer to have the same const-qualification as the input. You need to provide either const- and non-const overloads or a function template.

If you only need your real function updatePointer to move a pointer by a certain distance, regardless of the data pointed to, you could use std::advance instead.