Explain the semantics of the keyword const in the declaration of the member function get() in the code fragment below. Also, how does it affect the usability of get().

   struct S { int get() const; };

Explain why one uses the character '&' in the declarations of the arguments to the following function. T is some type.

   istream& operator>>(istream&, T&);

Explain the semantics and typical purpose when declaring a function parameter 'const T& x', where T is some type.

Study the following for loop:

   for (vector<int>::iterator it = v.begin(); it < v.end(); it++) {
      cout << *it << endl; 
   } 

There is no outright error, but which stylistic problems can you think of? How would you rewrite the code to make it, possibly, better?

There is a coding guideline stating: A base class destructor should either be public and virtual, or protected and nonvirtual.

There is also a corollary: Always write a destructor for a base class, because... complete why a base class destructor always should be written!

Suppose we have a type T. When passing an object of type T to a function, how would you declare the parameter type in the following two cases? Motivate!

— T is a simple type, such as e.g. int, and the parameter is used as an "in" parameter.

— T is a complicated type, e.g. a class type, and the parameter is used as an "in" parameter.

Explain how the calls of the function fun() below differ. 't' is a value, or object, of type T.

   fun(t);   // if the declaration of fun is: fun(T);
   fun(t);   // if the declaration of fun is: fun(T&);
   fun(t),   // if the declaration of fun is: fun(const T&);
   fun(&t);  // if the declaration of fun is: fun(T*);

Discuss semantics and consequences, e.g. regarding performance, in these four cases.

C++ have two fundamental parameter passing modes, which?

What is ment by "passing by reference to const"? Which is the purpose of that?

Below are four overloadings of a function fun.

   fun(T); 
   fun(T&);
   fun(T&&);
   fun(const T&);

Which of these can co-exist, without creating overload resloution ambiguity?

Which of those that can to co-exist will be chosen for different kind of arguments, such as lvalue, rvalue (xvalue, prvalue), const, non-const, etc.?

In C++ exceptions should be "thrown by value and caught by reference". Explain and motivate that citation.

Hint: The alternative to "throw by value" would be to "throw by pointer".

Which is the earliest possible resumption point in a program, after an exception has been thrown?

Which is the latest resumption point, if the program is to at all survive?

What happens to automatic objects that have been constructed in a try block when that block throws an exception? Assume that more than one such object has been constructed.

Suppose an exception may be thrown in a constructor. Discuss possibilities to handle such an exception within the constructor, or not, and how this affect the object in question and the context where the object is to be created.

A function-try-block could be used in a constructor. What would usually be the intended purpose of that?

Why does a function-try-block in a constructor often show not to be especially useful?

Suppose we have a function fun(), which may throw an exception of type std::bad_alloc, of type std::exception, or an exception not belonging to the std::exception hierarchy at all. The calling program shall take different actions for each of these three categories of exceptions. Show how a try block and handlers is declared to allow for this.

When and how does up-cast and down-cast, respectively, occur in C++?

What possible problems, if any, are associated with these kind of casts?

How can implicit conversions be provided for a class type?

How can the use of implicit conversion be eliminated?

What is required for using dynamic_cast?

For what purposes can dynamic_cast be used?

Compare and contrast the "new" type conversions, such as static_cast, dynamic_cast, etc., with the traditional type conversions, i.e. C cast (syntax: '(type) expr') and function call form (syntax: 'type(expr)').

Compare and contrast dynamic_cast and typeid expressions, when used in the context of a polymorphic class hierarchy.

When declaring an operator for a class we have, in most cases, several options, e.g. concerning membership and overloading in several versions.

Give one good reason for choosing membership over non-membership, when this is an option.

What is usually the purpose of overloading an operator for a class type in several versions?

A function template can be overloaded with both other function templates and with ordinary, non-template functions. There are basically four steps (at most) a compiler performs to find a match for a function call, where the last step is to conclude that there were no match at all for the call, or there were ambiguity because several functions matched, but none of them was a unique best match.

Which are, in order, the three first steps in function overload resolution?

Some operators cannot be overloaded at all, some operators must be overloaded as member functions, but for most overloadable operators there is a choice between member and non-member.

What you would chose, and why, if you were to overload operator<< to print objects of some type to an output stream.

Explain what is "wrong" with the following declaration of operator<<.

   class C {
   public:
      ostream& operator<<(ostream& os) {
         return os << i;
      }
   private:
      int i;
   };

Operator new is related to memory allocation. It has actually three forms, a plain form, a no-throw form, and a placement form. Describe each of these three forms.

Which are the, so called, special member functions, and what is their respective purpose/use?

The copy constructor is a, so called, special member function of a class. Elaborate on what's special about it and what it (usually) do.

The copy assignment operator is a, so called, special member function of a class. Elaborate on what's special about it.

Explain why it is appropriate to declare the copy constructor and the copy assignment operator in classes with dynamic memory allocation. What is the alternative?

Which operators are implicitly declared for class types? Describe shortly each operators purpose/use.

Note: There are quite a lot of operators defined, you may restrict to those which are more specifically related to class types.

When initializing a data member of a class in a constructor one can either use a member initializer, or use assignment within the constructor body.

Discuss differences, restrictions, guidelines, etc., for these two ways of initializing class data members.

Below is a fragmentary definition of a class C given.

   class C {
   public:
      explicit C(const C&);
   };

Explain what the declarator explicit mean.

What are the consequences of declaring this specific member function explicit?

Given the fragmentary class definition below, which of the class special member functions can be expected to have to be declared by user? Motivate! (T is some type.)

   class C {
      ... 
      private:
         T* v; 
   };

Given a base class Base, give a scenario for showing the difference(s) between protected inheritance and private inheritance, and point out the difference(s).

What is an abstract class? How is an abstract class defined?

Also, give at least one important feature of an abstract class.

What is a polymorphic class?

What specific features are related to polymorphic classes/objects?

Given three classes A, B and C, where B inherits from A and C inherits from B. Describe which code have access to the data member 'number' in class Test below.

   class Test {
   private:
      int number;
      friend class A;
   };

Explain the implications and probable purpose of the follwing code fragment:

   struct X {
      virtual ~X() = 0;
   };

   X::~X(){}

Suppose we use objects of some derived type in a program and we have, in some way, noticed that the destruction of such objects does not always work properly.

Give one explanation for such an error, and also a scenario where the error would occur?

Suppose we have a base class Base and a derived class Derived, each having a member function with the same signature. Also suppose that we have a base class pointer (Base*) to a derived class object and we call this member function through that pointer. Discuss what determines which function is actually called, the base class member function or the derived class member function.

There are many well-known pitfalls one might fall into when programming in C++. Explain what is wrong, and why, with the class C below.

   class C {
   public:
      A();
      ~A();
      virtual void memfun() = 0;
   };

Suppose multiple inheritance is involved, but no virtual base classes. Describe the initialization order for the sub-objects of an object of derived type (ordinary data members are also sub-objects) and also when in the process constructors are invoked.

How does the presence of virtual base classes affect the initialization order of the sub-objects of an object of derived type?

What different main kind of template parameters are there? Give an example of each kind, shown in a template declaration.

Give four examples of how (ordinary) function parameters and template parameters, either differ or have alike properties.

Explain why it is appropriate to define a specialization for char*, given the following function:

   template<typename T>
   T min(const T& a, const T& b) {
      return (a < b) ? a : b;
   }

Explain the difference between having a size argument for a data structur as a template parameter, as in

   template<typename T, int size> class Vector { ... };

compared to having it as a constructor argument, as in

   template<typename T> class Vector {
   public: 
      Vector(int size);
   };

std::max is a function template with one template type parameter, specifying the arguments and return value type. Explain why the following call is not allowed, and describe workarounds for making the call possible.

   int i = max(a,j);  // a is a double, j is an int.

Given the template declaration below, which requirements must an instantiation type for 'T' fulfill?

   template<class T> T fun(const T t);

Explain what the declaration of 'p' in the following code fragment means. Also, why is the keyword typename used?

   template<typename T> class C { 
      typename T::M* p; 
   };

What is the purpose of the standard library function adaptors?

Which are they?

Give examples of typical use, related to the standard library.

The standard library algorithms have iterators as parameters, categorized by five iterator categories.

Which are these five iterator categories, which are the leading features of each category, and what do they actually specify in practice?

The standard library algorithms have iterators as parameters, categorized by five iterator categories.

Relate the container iterators to the five iterator categories and elaborate some on the implications when attempting to apply a certain algorithm to a certain container type.

Some components of the standard library accept either a function object, a lambda expression, or an ordinary function as argument, while some components accept only function objects. What is the reason for that?