C++ Review: List of Concepts Covered (since midterm)

Input / Output Libraries

File I/O

• Understand types of files
  • Formatted text vs. binary
  • sequential vs. random access
• Understand the objects cin and cout, and what classes they are built from
• library <fstream>
  • class ofstream -- for output file streams
  • class ifstream -- for input file streams
  • Know how to declare file stream objects
• Know how to attach files to stream objects
  • member function open()
  • Default modes of opening for input files and output files
  • Understand the variation -- append mode
  • Know how to check to see if the file successfully opened
  • member function close() to close a file
  • stream can be reused for another file
• Using file streams -- similar syntax as with cout and cin
• Know the basic syntax for getting a user-entered filename (using an array of characters)

Other I/O Stream Features

• eof() function
• put() -- for character output
• The two get() functions, for extracting character input
  • Understand how each of these are called
  • Understand how they differ from reading a char with the extraction operator >>.
• peek()
• ignore()
• putback()
• Know how to pass stream objects into functions (by reference)
  • Understand how to build functions that allow this
  • Understand how to call functions that do this
  • Understand the relationship between istream and ifstream, for instance, and which objects can be passed with which formal parameters. (same for ostream / ofstream)

Misc -- cctype library

• A useful C library of character handling functions
• toupper(), tolower()
• Understand the boolean functions whose names start with is, for determining if a character fits in a certain given category

Arrays

Array Properties

• indexed collection of data elements of same type
• consecutive storage locations
• default indexing is 0 through size-1 (where size is the number of elements in the array)

Declaring Arrays

• format:   typeName variableName[size];
• Example:  int list[10]
• The type can be any basic type or any user-defined type
• the size must be known by the compiler, so it must be a positive integer literal or constant.
• 2-dimensional arrays
  • Example:  double table[5][10]

Initializing Arrays

• Can initialize arrays in the same line as declaration
• Format:    type name[size] = { list of elements };
  • Example:  int list[5] = {1, 3, 5, 9, 10};
• The list of elements goes in { } and is separated by commas
• may leave size box empty when initializing on the declaration line - compiler sets size.
• Can also initialize with for loops (good with regular patterns)
• Special case
  • strings: null-terminated character arrays
  • can initialize on the declaration with a string literal
    • Example:  char name[7] = "Marvin";
  • size must leave room for null-character '\0'

Using Arrays

• valid indices are 0 through size-1.
• may use any of these index numbers to access a single array element:
• may use any positive integer r-value to index arrays (i.e. variables, expressions, etc)
• it is the programmer's job to check for out-of-bounds index!
• Copying Arrays
  • Assignment between array names does not copy one array to another
  • If you want to copy one array to another, do it element by element (easy with a loop)

Using c-strings

• A c-string can be used like a normal array (of characters)
• cout and cin objects also work with c-strings (for output and input of words)
• >> operator for input stops at white space (space, tab, newline, etc.)
  • only good for one word at a time
• get and getline for reading strings from input
  • get, getline read up to specified delimiter -- can read entire sentences

Arrays as function parameters

• Know how to pass an array into a function
• Usually a good idea to pass in a size as well
• Function always has access to the array contents -- only the address is sent in
  • There's no pass-by-value vs. pass-by-reference with arrays
• Use const on the array parameter when the function shouldn't change the array

Array Usage and Algorithms

• Understand how to handle arrays that are declared to a certain size, but are not always "full" to their capacity
• Understand common array algorithms and patterns, including (but not limited to):
  • iterating through an array elements with a loop
  • Printing array contents
  • adding or counting array elements
  • finding largest/smallest element of an array
  • initializing array contents, with either formulas, user entry, or reading from a file
  • Using parallel arrays
  • Swapping or moving around array elements
• Arrays of strings
  • Implemented as a 2-D array of type char
  • The first dimension indicates how many strings
  • The second dimension indicates the allocated size for each string
  • Can refer to the name of one "string" by using the first index only

<cstring> library functions:

string objects

• Built with the string class library
• variable length, flexible
• Supports more intuitive operator notations, like assignment, comparisons, + for concatenation, etc
• Understand the difference between c-strings and string objects
• Know the commonly used operators, as well as the usage of basic member functions discussed in class

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

Enumerations

• a way to create new type with finite set of symbols as values
• Format: enum typeName { list of value symbols };
• Note: the value symbols are NOT strings
• the value symbols are implemented as constant variables by computer
• Why?
  • readability in source code.
  • creation of a type with a limited number of possible values
  • Enumeration as a function parameter type means validation probably not needed on parameters (by the function)
• Caution: Do not try to use in direct cin or cout statements (Remember, enum values are not strings!)

Arrays: Searching and Sorting

Searching

• Linear Search
  • The most obvious and intuitive search mechanism
  • Looks through array elements one by one until the item is located
  • takes longer than some specialized search techniques
• Binary Search
  • Depends on array being maintained in some sorted order
  • Looks at "middle" element, and decide which "side" of the array the element being searched for would have to be in
  • On each comparison, cuts number of possibilities in half
  • Runs much faster than linear search

Sorting

• Bubble Sort
  • Compares side-by-side elements. If out of order, swap them
  • Uses nested loops
  • Each run through inner loop "bubbles" one element to the end, its final position
  • Outer loop must run size-1 times
• Selection Sort
  • Also uses nested loops
  • Run through inner loop "selects" the largest (or smallest) element of the remaining items (i.e. the ones that are not yet in position), and swaps it with the end element
  • Outer loop must run size-1 times

C vs. C++

Formatted Output with printf

• Comes from the <stdio.h> library
• Understand the format of using printf

   printf(format_string, list_of_expressions);
  

• Understand how to use the formatting specifiers in the format string, and how to fill in the "blanks" with the remaining parameters
• Know the most common formatting specifiers (listed in the notes)
• Know how to adjust the formatting specifiers to also control field width, left/right justification, and decimal precision (when applicable)

Formatted Input with scanf

• Comes from the <stdio.h> library
• Understand the format of using scanf

   scanf(format_string, list_of_variable_addresses);
  

• The formatting specifiers are mostly the same as with printf
  • Remember that type double can be printed with the specifier %f, but with scanf, you need to use %lf for type double
• Understand how extra spaces in the format string allow input to skip past white space for characters and strings
  • Leading white space automatically skipped for consecutive numeric inputs
• Understand that the parameters in scanf are addresses, not variables -- so calls will frequently use the addess-of operator:

   int number;
   scanf("%d", &number);
  

• Understand how a scanf call works with character arrays (for reading c-style strings

Other C / C++ differences

• #include styles and library naming rules
• Know the C++-only keywords and features, especially features covered in this course, like:
  • new and delete
  • namespace and using
  • the bool type
  • casting
  • function overloading and default values on parameters
  • Pass by reference (and reference types in general)
• Understand the differences in C vs C++ syntax when creating and using structures and enumerations