C++ tips #1

Virtual Class Inheritance in C++

Java has notions of both class inheritance and interface inheritance, where interfaces are only sets of methods. To mimic this very useful behavior in C++ I often define classes with only a single method, such as

class Point;

struct PointSet
{
  virtual bool contains (const Point & const) const = 0;
};

class Point
{
  ...
public:
  inline bool in (const PointSet & point_set) const
  {
    return point_set.contains(*this);
  }
  ...
};

so that when defining objects which “are”, among other things, sets of points, they can inherit as so:

class Environment
  : public PointSet
{
  ...
public:
  virtual bool contains (const Point & point) const { ... }
  ...
};

In complicated class hierarchies, it can be useful to aggregate such abstract interface classes, e.g.,

struct MetricSpace
  : public PointSet
{ ... };

struct VectorSpace
  : public PointSet
{ ... };

struct BanachSpace
  : public MetricSpace,
    public VectorSpace
{ ... };

But oops, BanachSpace is now a PointSet in two distinct ways, i.e. via VectorSpace::contains and via MetricSpace::contains. To avoid this so called “diamond problem”

          PointSet                  PointSet    PointSet
         /        \                     |           |
  VectorSpace  MetricSpace   vs   VectorSpace   MetricSpace
         \        /                      \         /
         BanachSpace                     BanachSpace

C++ designers invented virtual inheritance which allows a unique inheritance of each interface-like method, so that in

struct MetricSpace
  : public virtual PointSet
{ ... };

struct VectorSpace
  : public virutal PointSet
{ ... };

struct BanachSpace
  : public virtual MetricSpace,
    public virtual VectorSpace
{ ... };

References

C++ FAQ Lite,
Wikipedia

BanachSpace::contains is unique.

C++0x

Gcc 4.4 and later support nice C++0x features like hash tables via std::unordered_map and auto typed variables, as in

std::unordered_map<
  std::pair,
  std::vector<std::pair > > widgets = get_widgets();

for (auto i = widgets.begin(); i != widgets.end(); ++i) {
  std::swap(i->second.first, i->second.second);
}

The new standard also allows variadic initializer lists with a small speed penalty.

My favorite features are:

• auto
• unordered_map
• static_assert