class C1 {
public:
  void foo();
}

class C2 {
public:
  void foo();
}

class Derived1 : public Base {
public:
  void Update() {
    member.foo();
  }
private:
  C1 member;
}

class Derived2 : public Base {
public:
  void Update() {
    member.foo();
  }
private:
  C2 member;
}

template  <class T>
class CTemplateBase
{
public:
    void Update()
    {
        member.foo();
    }
private:
    T member; // Generic type
}

class CDerived1 : public CTemplateBase<C1>
{
    // No common algorithms required here
}

class CDerived2 : public CTemplateBase<C2>
{
    // No common algorithms required here
}

template <class T>
class Derived : public Base {
public:
  void Update() {
    member.foo();
  }
private:
  T member;
}

class IFooable {
public:
  virtual void foo() = 0;
}

class C1 : IFooable {
public:
  void foo();
}

class C2 : IFooable {
public:
  void foo();
}

class Base {
public:
  void Update() {
    member->foo();
  }
private:
  IFooable* member
}

class Derived1 : public Base {
  Derived1 () : member(new C1()) {}
  ~Derived1 () { delete member; }
}

class Derived2 : public Base {
  Derived2 () : member(new C2()) {}
  ~Derived2 () { delete member; }
}