{\rtf1\ansi\ansicpg1252\uc1 \deff0\deflang1033\deflangfe1033{\fonttbl{\f0\froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman{\*\falt Thorndale};}
{\f2\fmodern\fcharset0\fprq1{\*\panose 02070309020205020404}Courier New{\*\falt Cumberland};}{\f29\fswiss\fcharset128\fprq2{\*\panose 020b0604020202020204}Arial Unicode MS;}{\f92\fswiss\fcharset128\fprq2 @Arial Unicode MS;}
{\f93\froman\fcharset238\fprq2 Times New Roman CE{\*\falt Thorndale};}{\f94\froman\fcharset204\fprq2 Times New Roman Cyr{\*\falt Thorndale};}{\f96\froman\fcharset161\fprq2 Times New Roman Greek{\*\falt Thorndale};}
{\f97\froman\fcharset162\fprq2 Times New Roman Tur{\*\falt Thorndale};}{\f98\froman\fcharset177\fprq2 Times New Roman (Hebrew){\*\falt Thorndale};}{\f99\froman\fcharset178\fprq2 Times New Roman (Arabic){\*\falt Thorndale};}
{\f100\froman\fcharset186\fprq2 Times New Roman Baltic{\*\falt Thorndale};}{\f109\fmodern\fcharset238\fprq1 Courier New CE{\*\falt Cumberland};}{\f110\fmodern\fcharset204\fprq1 Courier New Cyr{\*\falt Cumberland};}
{\f112\fmodern\fcharset161\fprq1 Courier New Greek{\*\falt Cumberland};}{\f113\fmodern\fcharset162\fprq1 Courier New Tur{\*\falt Cumberland};}{\f114\fmodern\fcharset177\fprq1 Courier New (Hebrew){\*\falt Cumberland};}
{\f115\fmodern\fcharset178\fprq1 Courier New (Arabic){\*\falt Cumberland};}{\f116\fmodern\fcharset186\fprq1 Courier New Baltic{\*\falt Cumberland};}{\f327\fswiss\fcharset0\fprq2 Arial Unicode MS Western;}
{\f325\fswiss\fcharset238\fprq2 Arial Unicode MS CE;}{\f326\fswiss\fcharset204\fprq2 Arial Unicode MS Cyr;}{\f328\fswiss\fcharset161\fprq2 Arial Unicode MS Greek;}{\f329\fswiss\fcharset162\fprq2 Arial Unicode MS Tur;}
{\f330\fswiss\fcharset177\fprq2 Arial Unicode MS (Hebrew);}{\f331\fswiss\fcharset178\fprq2 Arial Unicode MS (Arabic);}{\f332\fswiss\fcharset186\fprq2 Arial Unicode MS Baltic;}{\f831\fswiss\fcharset0\fprq2 @Arial Unicode MS Western;}
{\f829\fswiss\fcharset238\fprq2 @Arial Unicode MS CE;}{\f830\fswiss\fcharset204\fprq2 @Arial Unicode MS Cyr;}{\f832\fswiss\fcharset161\fprq2 @Arial Unicode MS Greek;}{\f833\fswiss\fcharset162\fprq2 @Arial Unicode MS Tur;}
{\f834\fswiss\fcharset177\fprq2 @Arial Unicode MS (Hebrew);}{\f835\fswiss\fcharset178\fprq2 @Arial Unicode MS (Arabic);}{\f836\fswiss\fcharset186\fprq2 @Arial Unicode MS Baltic;}}{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;
\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;
\red128\green128\blue128;\red192\green192\blue192;}{\stylesheet{\ql \li0\ri0\nowidctlpar\aspalpha\faauto\rin0\lin0\itap0 \fs20\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 \snext0 Normal;}{\*\cs10 \additive Default Paragraph Font;}{
\s15\ql \li0\ri0\nowidctlpar\aspalpha\faauto\rin0\lin0\itap0 \fs24\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 \snext15 Default;}{\s16\ql \li0\ri0\nowidctlpar\tqc\tx4320\tqr\tx8640\aspalpha\faauto\rin0\lin0\itap0 
\fs24\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 \sbasedon15 \snext16 header;}{\s17\ql \li0\ri0\nowidctlpar\aspalpha\faauto\rin0\lin0\itap0 \f2\fs20\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 \sbasedon15 \snext17 Preformatted Text;}{\*
\cs18 \additive \fs24\cf1\lang0\langfe255\langfenp255 \sbasedon20 page number;}{\*\cs19 \additive \fs24\cf1\lang0\langfe255\langfenp255 Numbering Symbols;}{\*\cs20 \additive \fs24\cf1\lang0\langfe255\langfenp255 WW-Default Paragraph Font;}}{\info
{\author Sharon Tuttle}{\operator CNRS}{\creatim\yr2002\mo9\dy26\hr8\min15}{\revtim\yr2003\mo12\dy12\hr13\min7}{\printim\yr2003\mo10\dy31\hr13\min36}{\version2}{\edmins1}{\nofpages5}{\nofwords1406}{\nofchars8018}{\*\company CNRS-HSU}{\nofcharsws9846}
{\vern8269}}\margt2093 \deftab1250\widowctrl\ftnbj\aenddoc\noxlattoyen\expshrtn\noultrlspc\dntblnsbdb\nospaceforul\hyphcaps0\horzdoc\dghspace120\dgvspace120\dghorigin1701\dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale100\nolnhtadjtbl \fet0
\sectd \sbknone\linex0\headery1440\sectdefaultcl {\header \pard\plain \s16\ql \li0\ri0\nowidctlpar\tqc\tx4320\tqr\tx8640\aspalpha\faauto\rin0\lin0\itap0 \fs24\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 {\fs16 CS 131 - Final Exam Study Suggestions
\tab \tab p. }{\field{\*\fldinst {\\page}}{\fldrslt {\lang1024\langfe1024\noproof 5}}}{
\par }{\fs16 Fall 2003
\par }}{\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang{\pntxta .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang{\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang{\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang{\pntxta )}}
{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang{\pntxtb (}{\pntxta )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang{\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang{\pntxtb (}{\pntxta )}}{\*\pnseclvl8
\pnlcltr\pnstart1\pnindent720\pnhang{\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang{\pntxtb (}{\pntxta )}}\pard\plain \s15\qc \li0\ri0\nowidctlpar\aspalpha\faauto\rin0\lin0\itap0 
\fs24\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 {\fs22 CS 131 - Fall 2003
\par }{\b\fs22 Final Exam Study Suggestions
\par }\pard \s15\ql \li0\ri0\nowidctlpar\aspalpha\faauto\rin0\lin0\itap0 {\fs22 
\par }\pard \s15\ql \fi-435\li420\ri0\nowidctlpar\aspalpha\faauto\rin0\lin420\itap0 {\fs22 *\tab last modified: 12-12-03, 1:00 pm
\par 
\par }\pard\plain \ql \fi-420\li420\ri0\nowidctlpar\aspalpha\faauto\rin0\lin420\itap0 \fs20\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 {\fs22 *\tab SOMETHING NEW: for the final, you may bring }{\b\fs22 a single 8.5" by 11" sheet}{\fs22  }{\b\fs22 
with your name prominently on it }{\fs22 on which you have }{\b\fs22 handwritten}{\fs22  the course material of your choice, along with your name --- this sheet }{\b\fs22 must be turned in with your final exam}{\fs22 
, and will not be returned. (You may write on both the front and the back, if you wish; and you must personally create/hand-write the sheet.)
\par }\pard\plain \s15\ql \fi-435\li420\ri0\nowidctlpar\aspalpha\faauto\rin0\lin420\itap0 \fs24\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 {\fs22 
\par }\pard\plain \ql \fi-420\li420\ri0\nowidctlpar\aspalpha\faauto\rin0\lin420\itap0 \fs20\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 {\fs22 *\tab final is CUMULATIVE!
\par }\pard \ql \fi-420\li840\ri0\nowidctlpar\aspalpha\faauto\rin0\lin840\itap0 {\fs22 *\tab if it was fair game for midterms #1 or #2, it is fair game for the final;
\par *\tab so, studying the review sheets for midterms #1, #2 would be wise; (they're still available from the course web page, under "Homeworks and Handouts", if you've misplaced your earlier copies);
\par *\tab studying the midterms #1 and #2 themselves would also be wise;
\par *\tab there may indeed be similar styles of questions as on those midterms;
\par }\pard\plain \s15\ql \fi-435\li420\ri0\nowidctlpar\aspalpha\faauto\rin0\lin420\itap0 \fs24\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 {\fs22 
\par *\tab remember: anything covered in assigned course reading, in lecture, or on a homework, is FAIR GAME.
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\fs22 
\par }\pard \s15\ql \fi-435\li420\ri0\nowidctlpar\aspalpha\faauto\rin0\lin420\itap0 {\fs22 *\tab 
the general style of the test will be similar to Midterms #1 and #2; there may be short-answer questions, and you will be both writing and reading functions, programs, and fragments of code. Concepts and terminology may also be involved.
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\fs22 *\tab note, too, that the tests *do* get harder as the semester progresses ---  your maturity as programmers should be increasing.
\par }\pard \s15\ql \fi-435\li420\ri0\nowidctlpar\aspalpha\faauto\rin0\lin420\itap0 {\fs22 
\par *\tab these are simply suggestions of some especially important concepts, to help you in your studying.
\par 
\par }\pard\plain \ql \fi-420\li420\ri0\nowidctlpar\aspalpha\faauto\rin0\lin420\itap0 \fs20\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 {\fs22 *\tab 
there COULD be one or more questions related to the course style standards, as we've discussed in class throughout the semester; questions about the program design recipe, contracts, etc. are likewise fair game, of course.
\par 
\par *\tab high points from material SINCE Midterm #2:
\par }\pard\plain \s15\ql \fi-435\li840\ri0\nowidctlpar\aspalpha\faauto\rin0\lin840\itap0 \fs24\cf1\lang1033\langfe255\cgrid\langnp1033\langfenp255 {\fs22 *\tab 
remember: if you did it on lab exercises or homeworks 9-13, it is fair game for the final, even if I forgot to mention it below... 8-)
\par 
\par *\tab }{\b\fs22 pass-by-reference }{\fs22 and }{\b\fs22 pass-by-value}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab 
what is a pass-by-reference parameter? What is a pass-by-value parameter? How do they differ? How can you tell them apart? What is the difference between the possible arguments for pass-by-reference and pass-by-value parameters?
\par 
\par *\tab when are pass-by-value parameters most appropriate? when are pass-by-reference parameters most appropriate?
\par 
\par *\tab expect at least one question involving pass-by-value and pass-by-reference parameters;
\par 
\par *\tab input parameters, output parameters, input/output parameters --- what are they? for each, what, in general, type of parameter passing is most appropriate?
\par 
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\fs22 *\tab }{\b\fs22 file input/output}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab why might you want to use a file for input? for output?
\par 
\par *\tab what C++ standard library do you need to include for the file input/output we discussed in class?
\par 
\par *\tab what do you need to declare to use a file as input? as output?
\par 
\par *\tab in C++, what is a file? a file stream? a mode?
\par 
\par *\tab how do you "open a file" for reading? for writing? for appending? How do you, then, essentially refer to the file from then on?
\par 
\par *\tab what does Savitch (and class style standards) recommend you do after each open of a stream? What do you also need to #include for this advice to work?
\par 
\par *\tab how do you then read information from a file? how do you then write information to a file?
\par 
\par *\tab how do you "close a file" that you've been reading or writing, once you are done?
\par 
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\fs22 *\tab }{\b\fs22 type casting}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab what do we mean by type casting?
\par 
\par *\tab what is the "preferred" way of accomplishing type casting in "newer" versions of C++?
\par 
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\fs22 *\tab }{\b\fs22 sizeof}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab what does this operator do? How can it be used? What does it return? How might it be helpful?
\par 
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\fs22 *\tab }{\b\fs22 more on output formatting}{\fs22 
\par }\pard \s15\ql \fi-435\li1275\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1275\itap0 {\fs22 *\tab we covered formatting a float/double to a certain precision earlier in the semester; now we introduced }{\b\fs22 field-width }{\fs22 manipulators...
\par 
\par *\tab be comfortable using, reading, and writing }{\b\fs22 setw}{\fs22 
\par }\pard \s15\ql \fi-435\li1710\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1710\itap0 {\fs22 *\tab what do you need to #include to use }{\b\fs22 setw}{\fs22 ?
\par 
\par *\tab if you want 3 values in a row to be printed in a field of a certain width, how many times and when must you call setw()?
\par 
\par *\tab if a value is "wider" than the setw() specified, what happens?
\par }\pard \s15\ql \fi-435\li1275\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1275\itap0 {\fs22 
\par }\pard \s15\ql \fi-435\li840\ri0\nowidctlpar\aspalpha\faauto\rin0\lin840\itap0 {\fs22 *\tab }{\b\fs22 switch statement}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab which of our 4 basic structures is a }{\b\fs22 switch}{\fs22  statement a 2nd implementation of?
\par 
\par *\tab for what situations is it particularly well-suited?
\par }\pard \s15\ql \fi-435\li1710\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1710\itap0 {\fs22 *\tab why might this be preferred to a collection of nested if-then-else-if's in some situations?
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 
\par *\tab is a switch statement a kind of loop?
\par 
\par *\tab what are the limitations on what types of expressions may be used for the case conditions?
\par 
\par *\tab what does "break" do, within a switch statement? what happens if it is omitted?
\par *\tab what does "default" do, within a switch statement?can it be omitted?
\par 
\par *\tab EXPECT to have to read, write, use switch statements; should
\par         be comfortable with its syntax and semantics.
\par 
\par *\tab if I gave you an appropriate collection of nested if-then-else-if's, could you convert it to an equivalent switch statement? Vice versa?
\par }\pard \s15\ql \fi-435\li1725\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1725\itap0 {\fs22 *\tab 
for every switch statement, is there always an equivalent collection of nested if-then-else-if's? for every collection of nested if's, is there always an equivalent switch statement?
\par 
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\fs22 *\tab }{\b\fs22 intro to pointers}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab what is a pointer? What does it do? How can it be used? 
\par 
\par *\tab How do you declare a pointer in C++? How do you set it/initialize it?
\par 
\par *\tab According to class style standards, if a pointer is currently not "pointing" anywhere, then what special value should it be set to? What do you need to #include in order to get the special value?
\par 
\par *\tab how can you make a pointer point to something? how can you affect or use what a pointer points to?
\par 
\par *\tab I might ask a question involving the boxes-and-arrows notation used in lecture; you might have to fill in the boxes and draw the arrows to complete a diagram based on a code fragment, for example.
\par 
\par *\tab If a pointer is pointing to an object, how can }{\b\fs22 ->}{\fs22  be used to call the methods associated with the object that the pointer is pointing to? (whew!)
\par 
\par *\tab we discussed using pointers and a MyNode class to implement a simple kind of }{\b\fs22 linked list}{\fs22 
\par }\pard \s15\ql \fi-435\li1725\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1725\itap0 {\fs22 *\tab what are some of the }{\b\fs22 tradeoffs}{\fs22  in implementing a set of items as a linked list instead of as an array?
\par 
\par *\tab how can you "walk through" all of the items in such a linked list?
\par 
\par *\tab you should be able to perform simple manipulations of linked lists (as demonstrated and practiced in lecture, on lab exercises, and on homeworks)
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\fs22 *\tab }{\b\fs22 dynamic memory allocation}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab how can you dynamically allocate memory from the freestore and have a pointer point to that memory?
\par }\pard \s15\ql \fi-435\li1755\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1755\itap0 {\fs22 *\tab you should be able to do this for arrays, simple values, and objects;
\par 
\par }\pard \s15\ql \fi-435\li1275\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1275\itap0 {\fs22 *\tab how can you then free or deallocate this memory when you want the pointer to point somewhere else?
\par }\pard \s15\ql \fi-435\li1710\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1710\itap0 {\fs22 *\tab what is the special syntax needed if you are doing this for a dynamically-allocated array?
\par 
\par *\tab what might happen if you do not do this?
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\b\fs22 
\par }{\fs22 *\tab }{\b\fs22 recursion}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab what is a recursive definition? what is a recursive function?
\par 
\par *\tab what is/are the }{\b\fs22 base case(s)}{\fs22  in a recursive function or definition? what is/are the }{\b\fs22 recursive case(s) }{\fs22 in a recursive function or definition?
\par }\pard \s15\ql \fi-435\li1725\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1725\itap0 {\fs22 *\tab I could ask you to identify them, for example;
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 
\par *\tab what are the }{\b\fs22 three requirements}{\fs22  for a "good" recursive function? (OK, I'll tell you:
\par }\pard \s15\ql \fi-435\li1725\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1725\itap0 {\fs22 1.\tab It must call itself somewhere (or it isn't recursive...!)
\par 2.\tab it MUST have at least one}{\b\fs22  }{\fs22 base case (a case where NO call to itself is made);
\par 3.\tab all recursive calls must be on "smaller" instances of the problem, such that it can be proven that, eventually, a base case WILL be reached;)
\par 
\par *\tab I could give a recursive definition or function, and ask you if it is "good" or not, and why or why not;
\par 
\par }\pard \s15\ql \fi-435\li1260\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1260\itap0 {\fs22 *\tab I could, of course, also describe a recursive situation, and ask you to write an appropr
iate recursive definition or recursive function; you might also have to read a recursive function and understand what it does.
\par 
\par *\tab you may have to write a recursive function;
\par 
\par }\pard \s15\ql \fi-435\li855\ri0\nowidctlpar\aspalpha\faauto\rin0\lin855\itap0 {\fs22 *\tab }{\b\fs22 makefiles}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab you will }{\b\fs22 not}{\fs22  have to write a makefile from scratch --- you should be able to read and reason about a given makefile, however;
\par }\pard \s15\ql \fi-435\li1710\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1710\itap0 {\fs22 *\tab you should be able to modify it appropriately, given a scenario;
\par *\tab you should be able to answer questions about it and what it does;
\par *\tab you should be able to give the command to use that makefile to re-compile a C++ program;
\par }\pard \s15\ql \fi-435\li1260\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1260\itap0 {\fs22 
\par }\pard \s15\ql \fi-435\li840\ri0\nowidctlpar\aspalpha\faauto\rin0\lin840\itap0 {\fs22 *\tab }{\b\fs22 objects part 2 - more on classes and objects}{\fs22 
\par }\pard \s15\ql \fi-435\li1305\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1305\itap0 {\fs22 *\tab what is a }{\b\fs22 friend}{\fs22  function? Why might you want to make a function a }{\b\fs22 friend }{\fs22 function? What is the syntax for doing so?
\par 
\par *\tab What is a destructor? a copy constructor?
\par 
\par *\tab What does it mean to overload an operator for a class? What is the syntax to do so?
\par 
\par *\tab What are the "big 3", and when do you need to explicitly (and appropriately) implement them within a class?
\par 
\par *\tab what is the initialization section of a constructor definition? How can you use this syntax?
\par 
\par *\tab }{\b\fs22 inheritance}{\fs22 
\par }\pard \s15\ql \fi-435\li1725\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1725\itap0 {\fs22 *\tab what is the idea behind inheritance? Why might it be beneficial?
\par 
\par *\tab how can one write a derived class based on some base class?
\par 
\par *\tab what does the derived class inherit from the base class? what does it NOT inherit?
\par 
\par }\pard \s15\ql \fi-435\li1320\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1320\itap0 {\fs22 *\tab }{\b\fs22 protected}{\fs22 , }{\b\fs22 private}{\fs22 , }{\b\fs22 public}{\fs22  - differences in visibility
\par 
\par *\tab difference between }{\b\fs22 redefined}{\fs22 , }{\b\fs22 overloaded}{\fs22  member functions
\par 
\par *\tab what is a function's signature? Given a function header, could you give its signature?
\par 
\par *\tab how can a member of a derived class call a redefined function from a base class?
\par }\pard \s15\ql \fi-435\li1725\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1725\itap0 {\fs22 
\par }\pard \s15\ql \fi-435\li870\ri0\nowidctlpar\aspalpha\faauto\rin0\lin870\itap0 {\fs22 *\tab }{\b\fs22 precompiler directives, old and new}{\fs22 
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 *\tab what do #include, #define, #ifndef/#endif do? When are they done?
\par 
\par *\tab how can #ifndef, #define, and #endif help in reducing redefinition errors involving #includes?
\par }\pard \s15\ql \fi-435\li1710\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1710\itap0 {\fs22 *\tab doing this, what do we consider to be good practice/good style in terms of what we should name the #define involved?
\par 
\par *\tab given a set of files making up a program, could you determine which files could benefit from this? Could you then add the specific appropriate lines of code to the appropriate files?
\par 
\par }\pard \s15\ql \fi-435\li885\ri0\nowidctlpar\aspalpha\faauto\rin0\lin885\itap0 {\fs22 *\tab there }{\b\fs22 COULD }{\fs22 be a question on }{\b\fs22 the increment operator}{\fs22  and how it behaves when used within a larger arithmetic expression;
\par 
\par *\tab there }{\b\fs22 COULD }{\fs22  be a question involving short-circult evaluation;
\par }\pard \s15\ql \fi-435\li1290\ri0\nowidctlpar\aspalpha\faauto\rin0\lin1290\itap0 {\fs22 
\par }}