1.17. const* and *const

1.17. `const` and `const`
	Chapter 1. C++ Introduction

1.17. `const` and `const`

[ fromfile: constptrs.xml id: constptrs ]

Suppose that you have a pointer ptr storing the address of a variable vbl:
```
Type* ptr = &vbl; 
```
there are three possible layers of protection that can be imposed with const.

If you want to make sure that ptr cannot point to any other memory location (i.e., cannot store a different address), you can write it one of two ways:
```
Type* const ptr = &vbl;
Type* const ptr(&vbl);
```
- If you want to make sure that the value of vbl cannot be changed by dereferencing ptr, you can write it in two ways:
```
const Type* ptr = &vbl;
const Type* ptr(&vbl);
```

If you want to impose both kinds of protection you can write:

const Type* const ptr = &vbl;
const Type* const ptr(&vbl);

Here is a good way to remember which is which: Read each of the following definitions from right to left (starting with the defined variable).

const char* x = &p;        /* x is a pointer to const char  */
char* const y = &q;        /* y is a const pointer to char  */
const char* const z = &r;  /* z is a const pointer to a const char  */

Volatile

volatile is another keyword that can modify variables and pointer definitions.
It can be used in the same places that const can be used.
volatile can be thought of as almost the opposite of const: It marks something that can be modified at any time, perhaps by another program, or another thread.
It is a hint to the compiler that there should be no optimization during access to it.

It can be used for variables, but more commonly, it is used for pointers.
Like const, it can be applied to the pointer or the addressed memory.
To declare a regular pointer to volatile memory, use this form:

volatile char* vcharptr;

To declare a volatile pointer to regular memory, use this form:

char* volatile vptrchar;

Example 1.30 demonstrates the two kinds of protection.

Example 1.30. src/constptr/constptr.cpp

#include <QTextStream>

int main() {
    QTextStream cout(stdout);
    int m1(11), m2(13);
    const int* n1(&m1);
    int* const n2(&m2);
    // First snapshot
    cout << "n1 = " << n1 << '\t' << *n1 << '\n'
         << "n2 = " << n2 << '\t' << *n2 << endl;
    n1 = &m2;
    //*n1 = 15; 
    m1 = 17;    
    //n2 = &m1; 
    *n2 = 16;   
    // Second snapshot
    cout << "n1 = " << n1 << '\t' << *n1 << '\n' 
         << "n2 = " << n2 << '\t' << *n2 << endl;
    return 0;
}
Output:

src/constptr> ./constptr
n1 = 0xbffff504 11
n2 = 0xbffff500 13
n1 = 0xbffff500 16
n2 = 0xbffff500 16
src/constptr>

	Error: assignment of read-only location
	m2 is an ordinary int variable, okay to assign
	Error: assignment of read-only variable 'n2'
	Okay to change target

Figure 1.5 shows two snapshots of memory at the noted spots in Example 1.30, to help clarify what is happening when the program runs.

Figure 1.5. Memory Snapshots

An object that is read-only when accessed through one pointer may be changeable when accessed through another pointer.
It is okay to assign the address of a variable to a pointer to const.
It is an error to assign the address of a const object to an unrestricted (i.e., non-const) pointer variable


1.16. Reference Variables		1.18. Review Questions