Introduction to Computer Science - C++
Constant Pointers
You can declare constant variables. Here is an example:
const int var = 9;
You can also declare pointers which are constant. But we must distinguish between two types of constant pointers. - a pointer that
points to a constant variable. (This pointer may be used to point to any number of constants in succession.)
const a = 34;
const int * ptr2Const; //something which points to a constant!
ptr2Const = &a;
- a pointer which can point to only one memory location ever.
int a = 34;
int * const constPtr = &a;
int * const constPtr points to a single memory location, it can never be changed once it is assigned.
Let us remeber something about constants. When you create a regular constant you must inialize it at the time when you declare it.
If you try to initialize it later, you will get a compiler error. This is because the compiler has no way to know that
you are not attempting to change the value of a constant. You think you are setting the value for the first time, but the compiler
just sees that you are assigning it a new value, and that is not allowed.
const int A;
A = 10; //compiler error
//rather you must do this
const int A = 10;
For the same reason, you must initialize a constant pointer when you declare it, as I did above. Just like it would be pointles to create
a constant variable and not initialize at the time of declaration because then you could never use it for anything, so too would it
be pointles to create
a constant pointer variable and not initialize it.
int * const constPtr;// pointless, constPtr can never serve any useful purpose
Let's see some examples in code that are based on the above principles.
<![CDATA[
const int F =10;
int * Fptr = &F;// compiles but illegal -- you are trying to point to a constant with a variable pointer
(*Fptr) = 11; // compiles but crashes program -- if this would really work, you would be changing a const!
const int * Fptr= &F; // the right way to do it
(*Fptr)= 11; //Now this won's compile, but that is good because you should not be changing constants
int c = 200;
int d = 300;
int * const C = &c;
int * const D ; //compiles but never useful just as useless as const int G; you should give D a value.
const int * B;
const int * E;
E = &d; // a pointer to a const can point to a variable also
(*D) = 17; // compiles but you are accessing memory that does not belong to you. Don't do this!
(*C) = 17; // compiles but you are accessing memory that does not belong to you. Don't do this!
C = &d ; or C = &c; // error because C is a read only variable, you can only assign C at time of declaration
B = &c; //compiles but you cannot change c via B because B thinks he is pointing to a constant
(*B)++;// wont compile because B thinks he is pointing to a const int
(*B) = 17; //error because B read only location, the location the B points to is suppose to be a constant
]]>
<![CDATA[
#include <iostream>
using namespace std;
int main()
{
int a = 9;
int b = 10;
const int * ptr = &a;//the thing pointed to is constant
int * const ptr1 = &a;// the address the pointer has is constant
int const * ptr2 = &a; // ptr and ptr2 are the same kind of pointer, no difference
//*ptr = 10;
ptr = &b;
//*ptr2 = 10;
ptr2 = &b;
//ptr1 = &b;
*ptr1 = 11;
int arr[10] = { 1,2,3 };
//arr = &b;
*arr = 12;
system("pause");
return 0;
}
]]>
© Nachum Danzig December 2017