CSCI 241 Midterm 2 Review Sheet

Function overloading

• Know how to do it
• Know the criteria that are used/not used to distinguish between the functions

Operator Overloading

• When we define a class, we can extend the definitions of some of the standard operators to make the operators work with the class as well as with the predefined data types. Overloading different operators can involve different problems.
• Keep in mind some examples. For instance, in class, we looked at the Rational class, which represents rational numbers. For the Rational class, we can easily overload the operators ==, !=, >, <, >=, <=, <<, >>, +, -, *, and /. Try writing out some of these.
• It does not always make sense to overload an operator. For instance, operator [] makes sense only if the class includes an array (or something like it) and the operators mostly make sense only for classes involving numbers.
• Bear in mind that operators can return various kinds of values including bool, the class itself, or a stream. The returned value may be a reference or a value.
• When we overload an operator, it can be a stand-alone function listed as a "friend" of the class, or it can be a stand-alone function using access methods, or it can be a member of the class. This distinction will usually make a difference in how many arguments the function has.
• There are a few operators that cannot be overloaded, such as ::, ., ?:, sizeof, and a few more.
• Some operators can be overloaded as either methods or as friends, while some others must be methods or must be friends. Know which is which.
• Some operators need to be overloaded twice.

Dynamic memory

• Know how to use the operators new and new [] to allocate memory.
• Know how to use the operators delete and delete [] to release memory that was allocated dynamically.
• Understand the difference between new and new [] and between delete and delete [].
• Understand the idea of a memory leak and how one can occur.
• Understand the idea of a dangling pointer and how one can occur.

Consequences of using dynamic memory in a class

• We will probably need to write our own copy constructor, destructor, and operator =. You should know what the arguments and return types are for each of these. You should understand why we cannot use the defaults in this case.

• If a class does not involve dynamic memory at all, we probably do not need to do any of the above.

• You should know the 5 steps involved in writing the code for the assignment operator (for instance, how do you check for self-assignment?), and likewise the steps involved in the copy constructor.

Two-dimensional arrays

• Know how to declare a 2-dimensional array
• Know the order in which data is stored in a 2-dimensional array
• Know how to access a specific element of a 2-dimensional array

Some specific key words and terms

const

• Know the different places it can be used
• Know which functions can be declared as const
• Understand why we want arguments to be const when it is appropriate

static

• Know what is meant by a static local variable
• Know what is meant by a static data member of a class
• Know what is meant by a static method of a class
• Know how to make use of a static data member or method

References

• Know the notation for indicating an argument is being passed by reference or a value is being returned by reference
• Understand why we want to use references when it is appropriate

friend

• Know what a friend is
• Know which operators must be friends and which cannot be friends
• Know where the word "friend" appears in the files we write

Exceptions

• Know how to use try, throw and catch
• Understand the sequence of events when an exception is thrown

Examples of kinds of coding questions that might appear

• writing the code to overload an operator for some class
• writing a copy constructor or a destructor for some class
• writing prototypes for various functions

Sources of information

• Take a look at the assignments done since the first exam.
• Look over the first exam and the review material for it.
• Look at the quizzes and the quiz question pool.
• There are web pages on most of these topics, and more or less all of it is in our textbook.

What is not on this test?

There is nothing on the test about stacks or queues, as these were not used in the homework that was due before the test.

Likewise, there is nothing on the test about templates or recursion.

A few practice questions

1. What are the return types and arguments of operators ++, [], +=, +, <, >>, and ==? Which of these can be const methods? Which is normally a friend function? Which ones have to be written twice?

2. Suppose I have a variable K of type Pile *. In my program, I have a line

            K = new Pile[15];

   and later I have a line

            delete K;

   What is wrong with this? What would be a better way to do it?

   Suppose instead I simply

            K = 0;

   Is that any better?

3. I want to have a class called Pair which provides ordered pairs (A, B) of elements of type float. The data elements of class Pair are two items of type float.
   1. Can I use the default copy constructor, destructor and assignment operator for the Pair class?

   2. Write the code for the equality operator == for the Pair class,

   3. Suppose I want to have a method called MakeMirror which returns a Pair containing the same two elements in the opposite order. (If the current instance contains (A, B), then MakeMirror() gives us (B, A).) Write the prototype statement for MakeMirror.

   4. Suppose I want to have a bool-valued function called IsMirror which will return true if two Pair objects contain the same elements in the opposite order. Write the prototype for IsMirror as a friend function.

4. Which of the following is not always provided as a default for every class (even though the default version may not be what we want)?

        A.  basic constructor
        B.  assignment operator
        C.  operator []
        D.  copy constructor
        E.  destructor

5. Suppose we have the following class:

            class Bundle
            {
             private:
              float Height;
              int * List;  // dynamically allocated array of int
              int Size;    // size of list
             public:
              Bundle();
              Bundle(Bundle & Other);
              // more stuff
            };

   We would also like to have an assignment operator. Here is some code for it. Fill in the blanks.

            ____________  Bundle::operator =(const Bundle & Other)
            {
             if (_________________________)
   
              {
               List = __________________;
   
               delete __________________;
   
               for (int I = 0; I < ____________; I++)
                 {
   
                  ________________________;
                 }
               Height = Other.Height; 
              }
   
             return _____________;
            }

6. For the Bundle class as described above, write the destructor.

7. For the Bundle class as described above, write the copy constructor.

8. Suppose we are overloading the insertion operator (output) << for a class called Blob. Can the function we write to do this be a member of the Blob class? If it can't, why not?

9. Write the code needed to declare a 2-dimensional array of integers with 4 rows and 8 columns. Now write the code needed to fill it with the values 1 through 32 (1-8 in row 1, 9-16 in row 2, etc). Now write the code needed to print it out sideways, that is, as 8 rows and 4 columns.

10. When would you want to have a static data member of a class? Suppose it is public; how can we set its value? Suppose instead it is private and we have static access method for it. Now what code would we need to set the value?

11. Suppose class Thing has a const method called XYZ. In the code for XYZ, we use another method called UVW. Does UVW have to be a const method?