–Powerful, but difficult to master

–Simulate pass-by-reference 

–Close relationship with arrays and strings

•Pointer initialization

–Initialized to 0, NULL, or address

•0 or NULL points to nothing

–Returns memory address of its operand

–Example

–yPtr “points to” y

–Returns synonym for object its pointer operand points to

–*yPtr returns y (because yPtr points to y).

–dereferenced pointer is lvalue

•*  and & are inverses of each other

–Pass-by-value

–Pass-by-reference with reference arguments

–Pass-by-reference with pointer arguments

•return can return one value from function

•Arguments passed to function using reference arguments

–Modify original values of arguments

–More than one value “returned”

–Value of variable should not be modified

–const used when function does not need to change a variable

•Principle of least privilege

–Award function enough access to accomplish task, but no more

•Four ways to pass pointer to function

–Nonconstant pointer to nonconstant data

•Highest amount of access

–Nonconstant pointer to constant data

–Constant pointer to nonconstant data

–Constant pointer to constant data

•Least amount of access

–Want function swap to access array elements

•Individual array elements: scalars

–Passed by value by default

•Pass by reference using address operator &

–Unary operator returns size of operand in bytes

–For arrays, sizeof returns

( size of 1 element ) * ( number of elements )

–If sizeof( int ) = 4, then

     will print 40

•sizeof can be used with

–Variable names

–Type names

–Constant values

–Increment/decrement pointer  (++ or --)

–Add/subtract an integer to/from a pointer( + or += , - or -=)

–Pointers may be subtracted from each other

–Pointer arithmetic meaningless unless performed on pointer to array

•5 element int array on a machine using 4 byte ints

–vPtr points to first element v[ 0 ], which is at location 3000

–vPtr += 2; sets vPtr to 3008

vPtr points to v[ 2 ]

–Array name like constant pointer

–Pointers can do array subscripting operations

•Accessing array elements with pointers

–Element b[ n ] can be accessed by  *( bPtr + n )

•Called pointer/offset notation

–Addresses

•&b[ 3 ] same as bPtr + 3

–Array name can be treated as pointer

•b[ 3 ] same as *( b + 3 )

–Pointers can be subscripted (pointer/subscript notation)

•bPtr[ 3 ] same as b[ 3 ]

–Commonly used to store array of strings

–Each element of suit points to char * (a string)

–Array does not store strings, only pointers to strings

–Contain address of function

–Similar to how array name is address of first element

–Function name is starting address of code that defines function

•Function pointers can be 

–Passed to functions

–Returned from functions

–Stored in arrays

–Assigned to other function pointers

–Integer value represented as character in single quotes

–'z' is integer value of z

•122 in ASCII

•String

–Series of characters treated as single unit

–Can include letters, digits, special characters  +, -, * ...

–String literal (string constants)

•Enclosed in double quotes, for example:

–char *strcpy( char *s1, const char *s2 )

•Copies second argument into first argument

–First argument must be large enough to store string and terminating null character

–char *strncpy( char *s1, const char *s2,      size_t n )

•Specifies number of characters to be copied from string into array

•Does not necessarily copy terminating null character

–Breaking strings into tokens, separated by delimiting characters

–Tokens usually logical units, such as words (separated by spaces)

–"This is my string" has 4 word tokens (separated by spaces)

–char *strtok( char *s1, const char *s2 )