CSC 2210 Final Exam Topics

This list may be incomplete; check back before exam

Students are allowed a single (standard-sized) page of notes, double-sided, typed or hand-written. You cannot simply create a verbatim copy of my notes; you must select key bits of pages and/or write significant parts yourself. You will be required to turn in the page at the end of the exam.

• See exam 1, exam 2 reviews
• Memory maps
  • Draw a memory map for double a, *b, **c; b = &a; c = & b; **c = 1.2;
• Declare identifier before can use it
  • When can an identifier be used before declaration?
• const
  • Is the following legal? void p(const int &x); p(3);
  • Write a function double that takes a value (of any type) and returns that value added to itself without changing the value. Write a fragment of code applying double to some declared, initialize variable, where the type of the variable is in namespace std.
• Arrays in C++ vs. Java, allocating array on stack vs. heap
  • Declare and define a variable names that is an array of pointers to std::string values. Allow up to 20 names. Set the first name to your own name, but all of the rest should be nullptr.
  • C & C++ arrays are passed by reference. Use a struct to create an array that is passed by value.
  • Are Java arrays passed by reference or value?
  • Assume you are implementing void dosomething(int nums[]); and write int s = sizeof(nums); in the body. What does this set s to? Is there a way to change the declaration of nums so s gets a different value?
  • Why are arrays not very useful in Java? Why are they more useful in C++?
  • What methods are available for C++ arrays?
• Declaring, dereferencing pointers
  • Given char *p, knowing the difference between p, *p, and &p
• Count number of negative values in an array of doubles without using []
• nullptr
• Initial value of int xs[100]; (depending on where declared)
• Floating-point constants: 6.022e23

Material since Exam 2

• Note 11: C - including
  • two-dimensional arrays, computing addresses with 2-d arrays
  • #define, dangers of using #define instead of templates
  • #if ... #else ... #endif
  • union - know what it means, you will not have to write coding using it
  • name vs structural equivalence for types
  Exam 2 sometimes includes more material from note 11 and sometimes less, but you should review it completely for the final.
• Note 12: Overloading/copy/move, STL, strings
  • Rule of 5: what are the items, why they are needed
  • recognize move constructor, explain what it does
  • write copy constructor
  • explain elements of assignment operator
  • describe which operator is used in auto x = a; vs. x = b;.
  • given std::string x;, risk of storing x.c_str() in a variable/object
  • =delete to suppress assignment operator, copy constructor, move operator
• Note 13: Streams, formatting
  • passing istream, ostream by reference
  • eof-controlled-loop pattern; why

            while ( ! eof ) { read; process }
    

    is a bad idea
  • purpose of istringstream and ostringstream: convert other data types into strings or from strings
  • using ifstream to read files, ofstream to write
  • .close as an optional operation for C++ files
  • buffer overflow and C-style strings, std::string
  • the concepts behind defining your own read and write operations on new data types
    • You will not have to write these, but you should understand their details.
• Note 14: STL iterators
  • be able to explain list<string>::iterator pos = todo.begin(), pos != todo.end()
  • difference between for(auto const & x : items), for(auto x : items), for(auto & x : items),
  • difference between static_cast and dynamic_cast
  • purpose of const_cast
• Note 15: memory in C (& C++), stacks
  • be able to explain how stack is managed: what is a stack frame, what is "sbp" in x86, why "sbp - 4" might be the first local variable, how is data stored in a stack frame
  • memory layout: text, rodata, data, bss, heap, stack
  • using malloc and free
  • The dangers of returning a reference to data allocated on the stack
• Note 16: Types
  • three definitions of a type
  • How static, dynamic types work: what has to be done at runtime for dynamic types, compile time for static types
  • advantages, disadvantages of int8_t, int16_t, etc.
  • what void* means, how used in C
  • differences between C and C++ type systems
  • casting using (type)
  • Ada and type equivalence rule based on names
  • Dangers of Ada's name equivalence type system
  • strongly typed: same results on all machines independent of representations
  • what it means to create a function pointer, how it is useful in C
  • Levels 1-6 of the computing abstraction list