C++ Pointers and Addresses

Addresses and Pointers

• Data items in memory are stored at a specific memory address
• The ampersand operator (&) retrieves the memory address of a left-value
• The ampersand only functions with left values

Addresses Within Structures

• The addresses for the elements of the structure will be different for each element
• Stored contiguously

Pointers

• A pointer is a left-value holding a memory address
• Pointers are declared using the asterisk symbol (*)

Typed Pointers

• Examples of typed pointers: char*, int*, double*, double**, enum answer*, struct player*, void*.
• Typed pointers identify errors during compilation
• Different types of pointers include:
  • Null pointer. Identified by the value NULL.
  • Constant pointer. Permits read-only access with write access denied.
  • Generic pointer of type void*.
  • Function pointer. This allows you to pass functions as arguments

Memory Space

• All pointers occupy the same amount of memory space
• Pointers contain addresses

Qualifiers

• const <type> *p: A read-only pointer
  • The pointed-to value can be read but not written
• <type> *const p: A constant pointer
  • The pointer's value cannot be modified
• Arrays often decay into constant pointers

Pointer Dereferencing

• Dereferencing accesses data at the memory location pointed to by a pointer
• Achieved through the asterisk operator (*)

Arrow Operator

• For a pointer p pointing to a structure with field champ, p->champ is equivalent to (*p).champ
• p->champ is preferred over (*p).champ

Pointer Operations

• Assignment (=)
• Conversion: implicit or explicit using (type*)
• Comparison
  • Equality of addresses (==)
  • Inequality of addresses (!=)
  • Comparison of addresses (<=, >=, <, >)
• Arithmetic
  • +: Pointer incremented towards the "right"
  • -: Pointer decremented towards the "left"
  • ++: Incrementation
  • --: Decrementation

Pointer Assignment and Conversion

• Pointers can be assigned to each other
• If p and q have the same type, the operation occurs without issue
• If p is more qualified (const) than q, an implicit conversion occurs
• Otherwise, an explicit conversion is required

Safe Pointer Conversions

• Converting a pointer should be avoided except in cases where
  • The pointer is of the same type but more qualified (const)
  • Conversion to or from a void pointer (void*)
  • Assigning the NULL value

Arrays and Pointer Arithmetic

• It's possible to get addresses of values in arrays

Pointer Arithmetic Details

• Accessing elements in arrays involves pointer arithmetic
• If 't' points to the start of the array:
  • t + i: points to the i-th value
  • t - 1: points to the value to the 'left'
  • t + 6: points to the value to the 'right'
  • (t + i) == &t[i] and *(t + i) == t[i]

Comparison Operators

• == specifies if two pointers contain the same address
• != negates ==
• <=, >=, <, > compares two pointers
• It's useful to have pointers that point toward the outside area to use them as bounds. However, errors can occur during deference

Operators+ and -

• With p as a pointer of type t*:
  • p + i: Shifts p by sizeof(t) * i bytes
  • p - i: Shifts p by sizeof(t) * -i bytes

Operators ++ and --

• ++: Increments a pointer to the next block of memory
• --: Decrements a pointer to the previous block of memory
• Useful for iterating through arrays

Function Static Variables

• Static variables can be associated with a function
• They are declared with the keyword static
• Static variables are allocated at the beginning of the program and freed at the end
• Initialized to 0 by default

Memoization

• When calling a function with the same arguments, simply reuse the previous result.

Functions as Arguments

• Enables passing functions as arguments to other functions
• Supported languages include Java, C++, Python, Haskell
• Examples include map and filter functions

Function Pointers

• Function pointers are typed
• They can be included inside of structs and arrays
• Syntax matters

Callbacks

• This can be implemented in C via function pointers
• Need to create a function and pass a pointer of the function to another function

Function Tables Implementation

• Function table: array containing function pointers
• Access functions using array indexing

Standard Library Functions

• qsort exists in the stdlib.h file
  • base: pointer to the first element of the array
  • nmemb: number of elements in the table
  • size: individual element size
  • compar: pointer to a function used to compare two elements
• void* enables greater abstraction
• Conversions or casts will be required to use it

Searching a Collection

• bsearch exists in the stdlib.h file

Standard I/O Library

• stdio implies the Standard Input Output library
• This is implemented when you #include <stdio.h>

Stdio Library

• Includes macros like:
  • EOF: denotes the end of file
  • stdin, stdout, stderr: standard input/output channels
  • NULL: signifies a null pointer and the FILE struct is used to represent data streams.
• Types:
  • FILE: data stream
  • size_t: number of bytes
  • fpos_t: position in a flux
• External variables such as optarg, opterr, optind, optopt manage function arguments.
• Consists dozes of functions

General Operations: Opening and Closing

• fclose(FILE *): closes a data stream
• fdopen(int, const char *): opens a data stream with a file descriptor
• fopen(const char *, const char *): opens a data stream
• freopen(const char *, const char *, FILE *): reopens a data stream

Removal and Renaming

• remove(const char *): deletes a file or directory
• rename(const char *, const char *): renames a file or directory

Temporary file management

• tmpnam(char *): return a temporary filename
• tmpfile(void): creates a temporary file

General information

• feof(FILE *): Checks if the end of the stream has been reached
• fileno(FILE *): Gets the file descriptor of a flux
• ctermid(char *): gets terminal name
• cuserid(char *): gets user's name

Error Handling

• clearerr(FILE *): clears EOF and error indicators
• ferror(FILE *): checks if there was an error
• perror(const char *): prints an error message to stderr

Character Manipulation

• fgetc(FILE *): reads a character from a flux
• getc(FILE *): equivalent to fgetc
• fputc(int, FILE *): write a character to a flux
• putc(int, FILE *): equivalent to fputc
• ungetc(int, FILE *): puts back a character on a flux

Standard Channels

• getchar(void): equivalent to getc(stdin)
• putchar(int): write a character to stdout

Byte Manipulation

• fread(void *, size_t, size_t, FILE *): reads bytes from a flux
• fwrite(const void *, size_t, size_t, FILE *): write bytes from a flux
• getw(FILE *): reads a words from a flux
• putw(int, FILE *): write a word to stdout

Manipulating Strings

• fgets(char *, int, FILE *): reads a line from a flux
• fputs(const char *, FILE *): write a string to a flux
• gets(char *): reads a string from stdin
• puts(const char *): write a string to stdout

Formatted I/O

• fprintf(FILE *, const char *, ...): write formatted output to a flux
• fscanf(FILE *, const char *, ...): reads formatted output from a flux
• vfprintf(FILE *, const char *, va_list): the same as fprintf with va_list arguments
• printf(const char *, ...): is the same as fprintf, but to stdout
• scanf(const char *, ...): is the same as fscanf, but from stdin
• sprintf(char *, const char *, ...): writes formatted output to a string
• snprintf(char *, size_t, const char *, ...): same as sprintf with safety
• sscanf(const char *, const char *, int ...): parses formatted input from a string.
• vprintf(const char *, va_list): formatted output with va_list on stdout.
• vsnprintf(char *, size_t, const char *, va_list): same as snprintf with va_list
• vsprintf(char *, const char *, va_list): same as sprintf with va_list

Moving through data streams

• fseek(FILE *, long int, int): adjust position in a flux
• fseeko(FILE *, off_t, int): same as fseek withoff_t offset
• ftell(FILE *): returns courante position in a flux
• ftello(FILE *): same as ftell using the type off_t
• fsetpos(FILE *, const fpos_t *): Modifies the position in a flux
• fgetpos(FILE *, fpos_t *): Retrieves the position in a flux
• rewind(FILE *): reset position at the beginning of the file

Arguments and Buffers

• getopt(int, char * const[], const char): Manages command line arguments. LEGACY

Buffers

• fflush(FILE *): flushes a buffer
• setvbuf(FILE *, char *, int, size_t): configures buffereing strategy in flux
• setbuf(FILE *, char *): configure unbuffered flux strategy

Inter-Process Communication

• pclose(FILE *): close a channel communication
• popen(const char *, const char *): open a channel communication

Locking threads

• flockfile(FILE *): Lock a flux
• ftrylockfile(FILE *): Tries version without lock
• funlockfile(FILE *): Unlock a flux
• getc_unlocked(FILE *): not secured flux
• putc_unlocked(int, FILE *): not secured flux
• getchar_unlocked(void): not secured flux
• putchar_unlocked(int): not secured flux

Standard channels

• Programs interact with standard I/O through three channels:
  • Stdin (canal 0): Standard input.
  • Stdout (canal 1): Standard output
  • Stderr (canal 2): Standard error.
• By default:
  • Stdin reads keyboard input line buffered
  • Stdout displays to the terminal line buffered
  • Stderr displays to the terminal unbuffered

Standard Input

• A program can read data
• Listens for the keyboard

Standard Output

• A program can write it to the terminal.
• The default is to write the data

Standard output for errors

• Can write using standard error output
• By default, it displays on the terminal

Return values

• Unix programs return code that indicate program was successful
• Has semantics for its exit status:
  • Zero for normal termination
  • Non-zero, indicates abnormal termination
• The return value is stored into a variable

C's returning

• Value from main
• Good Practice: always indicates returning value
• Function to exit - Allows clean exit from a program - Flushes open streams - Removes temporary files