C++ Review: List of Concepts Covered (since test 2)

Pointers

Basics

• A pointer is a variable that stores an address
• declaration format: typeName * variableName;
• target -- the item that a pointer points to
• dereferncing the pointer (to get to the target)
  • if p is a pointer, *p is the target (dereference the pointer with *)

Initializing pointers

 p = _____

1. NULL pointer
   • pointer that stores address 0. Has no valid target.
   • 0 is the only literal number that can be assigned to a pointer
2. Another pointer of the same type
   • a pointer is thought of as a "pointer to a" specific type
   • different pointer types can NOT be assigned to each other (automatic type conversions like on the basic types do not apply)
   • An array name counts as a pointer (to whatever type the array is built from)
   • A string literal (e.g. "Hello") is an r-value that counts as a (const char * )
3. The "address of" an existing variable
   • Using & on a variable means "address of" that variable.
     • Note this is NOT the same as using & in a declaration (with a type in front of it). That's a reference variable -- used in Pass By Reference
   • Example: &x means "address of x"
   • May assign an address to a pointer (of matching type)
     • p = &x;
4. a new operation (Dynamic Allocation -- See below)

Pointer Arithmetic:

• can subtract two pointers
• can add or subtract integers to or from pointers
  • does not use literal integer.  adds or subtracts that many units of pointer type
  • i.e. add x to a pointer-to-int actually adds (x * (size of an int))

Pointers and Arrays:

• the name of an array is a pointer to the first element of the array
• array access through a pointer can be done with bracket operator p[3]
• array access through pointer can be done with pointer arithmetic *(p+3)
• May assign array name to a pointer of matching type:

   int list[10];
   int * ptr;
   ptr = list;
  

  ptr could now be used to access array elements, like the array name
   
• Name of statically declared array cannot be assigned another value (it's like a pointer that is a constant -- it's bound to the array)

Pass by Address:

• third type of parameter passing -- pass in the pointer, or address
• Parameter type is pointer type (e.g. int * )
• passes in copy of address, function can use address to find original data
• very useful for passing arrays in and out of functions (by their name)
• Can use to accomplish same as pass by reference. Reference parameters easier when using single variables, though
• For arrays, the following two notations are equivalent in meaning:

    void Function1(int * arr );
    void Function1(int arr[] );
  

• Const:
  • declaring a parameter as const on a pass by reference or address
  • does not make copies of the data, but prevents changing original data
  • const int * p; -- pointer p CAN be changed. Target cannot be changed.
  • different combinations with "const" can make pointer constant, too.

Dynamic Memory Allocation

Memory Allocation Categories

• Static -- compile time. size and types known in advance
• Dynamic -- run time. sizes and amounts can be set while program running

Dynamic Allocation, Deallocation

• create dynamic space with the operator new.
  • always use a TYPE after the word new.
• The new operator also returns the address of the allocated space
  • use a pointer to store this address
• can dynamically allocate basic variables and arrays
• deallocate dynamically allocated memory with operator delete
  • apply delete to the pointer, and it de-allocates the target.
  • Use delete [] for arrays

Dynamically resizing an array (application example):

1. dynamically create a new array of the needed size (need another pointer for this)
2. copy the data from the old array to the new one (use a for-loop)
3. delete the old dynamic array (keyword delete)
4. change the pointer so that the new array has the original name

Structures

• struct: A collection of data elements, encapsulated into one unit
• A structure definition
  • a blueprint for what this type of structure variable will contain
  • When a structure is defined, it becomes a new type
  • Know how to define a new structure (with keyword struct)
• The new type can be used to declare structure variables
  • Know how to declare structure variables, arrays of structs, pointers to structs, etc
• Understand the syntax variations, like creating struct variables right after the blueprint, including when the struct definition is not given a name
• Understand how to put structure variables inside of other structure definitions

Using structures

• Understand the dot-operator notation for accessing the contents of a structure

   structVariable.internalData
  

• Understand the arrow operator notation, for accessing the contents of a structure when you have a pointer to the structure

   structPointer->internalData
  

• Examples of both:

   Student s;
   Student* sptr = &s;
  
   s.gpa = 3.75;
   sptr->idNumber = 12345;
  
   // understand that this last one is equivalent to:  (*sptr).idNumber
  

• Know how to initialize a struct on the declaration line, with the set-notation shortcut

   Date d = {12, 25, 006};
  

• Be able to apply all these techniques (dot-operator, arrow operator, and initializer set) to the case of nested structs as well -- i.e. structure variable as a member of another structure)
• Understand how the assignment operator works with structures
  • However, you cannot expect just any operator to work with structures. Assignment is a special case
• Understand how to pass structure variables in and out of functions
  • Understand how this fits into what we know about pass-by-value, pass-by-reference, and pass-by-address

Unix Topics

Input/Output redirection and pipes

• Understand what is meant by:
  • standard input
  • standard output
  • standard error
• Know how to use these symbols in unix commands:
  • <
  • >
  • >>
  • |
• Specifically, know how to:
  • Re-direct standard input into a command to come from a file
  • Re-direct the standard output from a command to go to a file (instead of the screen)
  • Re-direct the standard output from a command to be appended to a file
  • "Pipe" the output from one command to become the input to another command

tar utility and compression with gzip

• tar - tape archive utility
• Important flags:
  • c = create
  • x = extract
  • t = table of contents
  • f = specify a filename (must be followed by tar file name)
  • v = verbose (extra feedback on output when command run)

• gzip and gunzip
• compress/decompress a file
• understand how this differs from the Windows .zip format

diff and grep

• grep -- search for words/patterns in files or std input
  • -i -- ignore upper/lower case differences in search
  • -n -- show line numbers in results
  • -l -- show filenames only in results
• diff -- print the difference between two text files
  • -i -- ignore upper/lower case differences in results
  • -b -- treat consecutive spaces as one
  • -w -- ignore white space on a line