CSE687-Online Course Summary

C++ derives most of its language elements and function structure from the C programming language, which in turn, inherited those things from Algol, a European language. It derives its notions of class from SmallTalk.

A class is a language construct that binds together member functions and data, providing access to users only to public member functions, not to its data. This encapsulation enables the class to make strong guarantees about validity of its data.

For each of your classes, always consciously choose between providing construction, assignment, and destruction operations, allowing the compiler to generate them, or disable them.

An abstract data type is simply a value type, e.g., it provides copying, assignment, and move operations that allow instances of the type to behave like built-in types.

Templates are compile time constructs that allow us to avoid writing a lot of nearly identical code for classes that could sensibly use any of several concrete types, perhaps as arguments to member functions or as instances of member data. Containers are a good example. Templates are also useful for building functions that accept callable objects, i.e., function pointers, functors, or lambdas. We use template functions to accept instances of any of these distinct types. Thread constructors are a good example. Here are a few interesting examples of template use:

• Defining C++ properties using templates
• Graph class representing networks of nodes connected with arcs
• Demonstration of several ways to traverse m-ary tree structures

There are many more linked in the Templates lecture page.

Classes have four relationships:

• Inheritance:

  A derived class inherits all it's base's members. Non-virtual base functions should not be redefined in the derived class. Virtual member functions may be redefined in the derived class. Pure virtual functions must be redefined.

• Composition:

  Instances declared as class data members are composed by the class, creating a strong owning relationship. Composed members are always constructed when the composer is constructed, and destroyed when the composer is destroyed.

• Aggregation:

  A class aggregates a data member when it holds a pointer to the member instance on the native heap. Creation of an instance of some type as local data in a member function is also considered to be aggregation. Aggregated instances are owned by the aggregator, but this is a weaker relationship than composition, as the aggregated instances do not exist until code in the aggregator creates them.

• Using:

  A class uses an instance of some other class when it is passed the instance to one of its public member funtions by reference. Using is a non-owning relationship and your classes should respect the owning code by doing nothing to invalidate the used instance. Passing an instance by value to a member function is really aggregation, because the receiving class creates and uses its own copy.

These four relationships are all that are needed to build Object Oriented programs.

Compound objects are instances of classes that use inheritance, composition, and aggregation of other classes to carry out their mission. We need to be careful, especially with initialization, to ensure they operate as expected. Here is a good example of the initialization and use of compound objects.

A functor is a class that defines operator(). That means that instances can be "invoked" like this:

  class AFunctor {
  public:
    AFunctor(const X& x) : x_(x) {}
    void operator()(const Y& y) { /* do something useful to x_, using y */ }
    X value() { return x_; }
  private:
    X x_;
  };

  AFunctor func;
  Y y;
  func(y);          // syntactically looks like a function call
  func.operator(y); // equivalent to the statement above
                      

A lambda is an anonymous callable object that can be passed to, and returned from other functions. A lambda is really a short-cut to define a functor. A very useful feature of lambdas is their capture semantics. They can store data defined in their local scope, to be used later when they are invoked.

  std::function makeLambda(const std::string& msg) 
  {
    std::function<void()> fun = [=]()  // [=] implies capture by value, [&] implies capture by reference
    {
      std::cout << "\n  displaying captured data: " << msg; 
    };
    return fun;
  }

  // in some other scope

  std::function myFun = makeLambda("hello CSE687-OnLine");
  std::cout << "\n  using Lambda: " << myFun() << "\n";
                      

A callable object is any C++ construct that can be invoked using parentheses, callable(...). Function pointers, functors, and lambdas are all callable objects. Here's a function that accepts and invokes any callable object that takes no arguments:

  template<typename T>
  void invoker(T& callable)  // callable could be a lamda with captured data
  {
    callable();  // use captured data instead of function arguments
  }
                    

Exceptions are a language defined mechanism for handling errors. Exception handling uses instances of std::exception and the key words throw, try, and catch. You should always throw exceptions by value and catch them by reference.

A namespace defines a compile-time scope used to distinguish between two or more type or function names with the same value but that have distinct definitions in separate places in code for a single compilation unit. A namespace extends the name of a type, for example, by prepending the type name with the namespace name, i.e., MyNamespace::MyType.

The C++ language has a surprisingly short list of dark corners, e.g., compilable constructs that may cause subtle errors. These all have to do with causing Liskov Substitution to fail by improper overloading, overriding, or failing to provide virtual destructors.