2

I can't figure out how to tell C that I want a pointer that will not move. It will always point to the same array. That said, the array members are not constant, but the array itself is global and so, it is at a fixed position.

So, when I code this:

#include <stdio.h>

int v[2]={0, 1};
const int *cpv=v;

int main(void)
{
    v[1]=2;     printf("%d\n", v[1]);
    *(cpv+1)=3; printf("%d\n", v[1]);
    cpv[1]=4;   printf("%d\n", v[1]);
}

And get this errors:

constp.c: In function ‘main’:
constp.c:9: error: assignment of read-only location '*(cpv + 4u)'
constp.c:10: error: assignment of read-only location '*(cpv + 4u)'

I understand that the compiler thinks I need a const int v[2] to use with a const int *iv. How do I get a constant pointer to do the job?

If you see the error message, I'm not even moving the pointer (like pv++). I'm just dereferencing it dislocated some bytes.

If I do this:

int *pv=cpv;
*(pv+1)=5;  printf("%d\n", v[1]);
printf("%p == %p !?\n", cpv, pv);

I get this warning, but it works:

constp.c:9: warning: assignment discards qualifiers from pointer target type
pointer# ./constp 
5
0x601020 == 0x601020 !?

Thanks, Beco.

DrBeco
  • 11,237
  • 9
  • 59
  • 76

5 Answers5

5

Move the const qualifier:

int *const cpv=v;

Explanation: in the C declaration rules, this is read from right to left starting at the identifier: "cpv is a constant pointer to int". Your version would be read "cpv is a pointer to int constant".

Note that cpv+1 will still get you a pointer to the int after *cpv; making a pointer const only prevents ++, --, += and -= on it.

Fred Foo
  • 355,277
  • 75
  • 744
  • 836
  • Thanks! Very nice explanation. My intention is exactly that: the pointer will always point to the first element of that array. ;) – DrBeco Apr 03 '11 at 22:05
2

You are using a pointer to const, not a const pointer.

const int *cpv=v;

should turn into:

int *const cpv=v;

Adrian Marinica
  • 2,191
  • 5
  • 29
  • 53
2

Pointers kind of "read backwards":

const int * p;

In this case, "p" is a (variable) "pointer" to a "const int". Literally, read that backwards, with the '*' meaning "pointer": "Pointer ... to int const".

Curiously, the following is the same thing:

int const * p;  // same thing

Reading backwards, it says, "pointer ... to const int" (the same thing).

So, if you want your pointer to be "constant" (not variable), you need to read-backwards and do just that:

int * const p;  // p cannot change

Now, "p" is a constant pointer to a non-constant integer. Not to belabor, but reading backwards that's, "const pointer ... to int".

Using the "same thing" example above, we can now have a constant pointer to a constant integer (the following are the same):

const int * const p;
int const * const p;

You should read them backwards, and they both say the same thing, "contant pointer ... to constant int".

charley
  • 5,913
  • 1
  • 33
  • 58
1
#include <stdio.h>

int v[2]={0, 1};
//const int       *      cpv=v; // cpv is a pointer to int const
//      int const *      cpv=v; // cpv is a pointer to const int == same as above ==
        int       *const cpv=v; // cpv is a constant pointer to int
//      int const *const cpv=v; // cpv is a constant pointer to const int
//const int       *const cpv=v; // cpv is a constant pointer to int const == same as above ==
//const int const *const cpv=v; // == same as above ==

int main(void)
{
    v[1]=2;     printf("%d\n", v[1]);
    *(cpv+1)=3; printf("%d\n", v[1]);
    cpv[1]=4;   printf("%d\n", v[1]);
}
pmg
  • 106,608
  • 13
  • 126
  • 198
1
int * const cpv=v;

Having said that, why do you need the pointer at all? The compiler will be able to do a better job if you would access the variable v directly. If you go via a pointer, the generated code have to read the pointer from memory each time you access the array.

Lindydancer
  • 25,428
  • 4
  • 49
  • 68
  • LOL! Thanks @Lindy, I always simplify my questions to the very core of the problem. Actually it is a pointer to a structure from an outside API that has a lot of long names, and I want to access its members using a simplified version that intends to look like an array, and the pointer will do just that! :) Curious you are, aren't you? ;) You can read more here: [struct just like an array](http://stackoverflow.com/questions/5524552/access-struct-members-as-if-they-are-a-single-array) – DrBeco Apr 03 '11 at 22:09
  • Of course I'm curious! However, as a compiler developer, I'm sometimes asked to check customer projects. One anti-pattern I've seen is using global constant pointer to a global array, forcing to the compiler to perform literally thousands of extra memory accesses, slowing down the program and occupies previous space. – Lindydancer Apr 04 '11 at 08:20