Chapter 7: C Pointers

the name of an array is equivalent to ...

&arrayname[0]

Pointer/offset Notation

*( pointer + offset )

arithmetic operations that may be performed on pointers

++, --, +, +=, =, -=

default for an array name

An array name is a constant pointer to the beginning of the array. All data in the array can be accessed and changed by using the array name and array indexing

int b[ ] is _______ with int *b

interchangeable

The four ways to pass a pointer to a function

non-constant-pointer to non-constant-data, a constant pointer to non-constant data, a non-constant pointer to constant data, and a constant pointer to constant data

Both ++vPtr and vPtr++ ...

increments the pointer to point to the next location in the array

Indexing and offsets

All are equivalent, assuming *bPtr = b: b[ 0 ] *(b + 0) bPtr[ 0 ] *(bPtr + 0)

* (unary operator)

Also called the indirection operator or dereferencing operator. It returns the value of the object to which its operand (i.e, a pointer) points

indexing and offsets for multidimensional arrays

In general, these are equivalent: s[ i ][ j ] *(s[ i ] + j ) * (*( s + i ) + j )

Initializing a pointer to 0

Initializing a pointer to 0 is equivalent to initializing a pointer to NULL, but NULL is preferred. When 0 is assigned, it's first converted to a pointer of the appropriate type. The value 0 is the only integer value that can be assigned directly to a pointer variable.

A pointer may be initialized to ...

NULL, 0, or an address

int y = 5; int *yPtr; yPtr = &y;

The statement yPtr = &y assigns the address of the variable y to pointer variable yPtr. Variable yPtr is then said to "point to" y

int *countPtr

This definition specifies that variable countPrt is one of type int* (i.e, a pointer to an integer)

offset

When a pointer points to the beginning of an array, adding an offset to the pointer indicates which element of the array should be referenced, and the offset value is identical to the array index

pointer to void ( i.e., void * )

a generic pointer that can represent any pointer type. All pointer types can be assigned to a pointer to void, and a pointer to void can be assigned a pointer of any type. A pointer to void cannot be dereferenced

NULL

a symbolic constant defined in <stdio.h>. A pointer initialized to NULL points to nothing.

& (address operator)

a unary operator that returns the address of its operand

principle of least privilege

always award a function enough access to the data in its parameters to accomplish its specified task, but absolutely no more

A constant pointer to non-constant data ( ex: int * const ptr )

always points to the same memory location, and the data at that location can be modified through the pointer. This is the default for an array name

constant pointer to constant data ( ex: const int *const ptr = &x )

always points to the same memory location, and the data at that memory location cannot be modified. The least access privilege is granted by this

structure

an aggregate data type that is capable of storing related data items of different data types under one name. structures are always passed-by-value, unlike arrays

The statement x = v2Ptr - vPtr would ...

assign to x the number of array elements from vPtr to v2Ptr

A pointer can be assigned to another pointer if ...

both have the same type (exception is void*)

Both --vPtr and --vPtr ...

decrements the pointer to point to the previous element of the array

string array

each entry in the array is a string, but in C a string is essentially a pointer to its first character. So each entry in an array of strings is actually a pointer to the first character of a string

const qualifier

enables you to inform the compiler that the value of a particular variable should not be modified

%p

printf conversion specifier that outputs a memory location as a hexadecimal integer on most platforms

Indirection

referencing a value through a pointer

to determine the number of elements in an array, the following expression can be used:

sizeof( arrayname ) / sizeof( arrayname[ 0 ] )

If an attempt is made to modify a value that is declared const, ...

the compiler catches it and issues either a warning or an error, depending on the particular compiler.

non-constant pointer to non-constant data ( ex: char *ptr )

the data can be modified through the dereferenced pointer, and the pointer can be modified to point to other data items. grants the highest level of data access

non-constant pointer to constant data ( ex: const char *ptr )

the pointer can be modified to point to any data item of the appropriate type, but the data to which it points cannot be modified

When an integer is added or subtracted from a pointer, ...

the pointer is not incremented or decremented simply by that integer, but by the integer times the size of the object to which the pointer refers

sizeof

unary operator that determines the size in bytes of an array (or any other data type) during program compilation

stimulating call-by-reference

using pointers and indirection operators

All functions in C are passed by ...

value

Pointers

variables whose values are memory adresses. Normally, a variable directly contains a specific value. A pointer, on the other hand, contains an address of a variable that contains a specific value. In this sense, a variable name directly references a value, and a pointer indirectly references a value