CSE687 Course Summary

/////////////////////////////////////////////////
// Converter class
// - supports converting unspecified types
//   to and from strings
// - a type is convertible if it provides 
//   insertion and extraction operators

template <typename T>
class Converter
{
public:
  static std::string toString(const T& t);
  static T toValue(const std::string& src);
};
//----< convert t to a string >------------

template <typename T>
std::string Converter<T>::toString(const T& t)
{
  std::ostringstream out;
  out << t;
  return out.str();
}
//----< convert string to instance of T >--
/*
*  - the string must have been generated by
*    Converter<T>::toString(const T& t)
*  - T::operator>> must be the inverse 
*    of T::operator<<
*/
template<typename T>
T Converter<T>::toValue(const std::string& src)
{
  std::istringstream in(src);
  T t;
  in >> t;
  return t;
}

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

• 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.

  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
                      

  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";
                      

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