struct Number {
    typedef int value_type;
    int n;
    void set(int v) { n = v; }
    int get() const { return n; }
};

template <typename BASE, typename T = typename BASE::value_type>
struct Undoable : public BASE {
    typedef T value_type;
    T before;
    void set(T v) { before = BASE::get(); BASE::set(v); }
    void undo() { BASE::set(before); }
};

template <typename BASE, typename T = typename BASE::value_type>
struct Redoable : public BASE {
    typedef T value_type;
    T after;
    void set(T v) { after = v; BASE::set(v); }
    void redo() { BASE::set(after); }
};

typedef Redoable< Undoable<Number> > ReUndoableNumber;

int main() {
  ReUndoableNumber mynum;
  mynum.set(42); mynum.set(84);
  cout << mynum.get() << '\n';  // 84
  mynum.undo();
  cout << mynum.get() << '\n';  // 42
  mynum.redo();
  cout << mynum.get() << '\n';  // back to 84
}

struct ITask {
    virtual ~ITask() {}
    virtual std::string GetName() = 0;
    virtual void Execute() = 0;
};

// abstract base class which implements Execute() and provides logging feature. Derived classes must implement OnExecute().
class BaseLoggingTask : public ITask {
public:
    void Execute() override {
        std::cout << "LOG: The task is starting - " << GetName() << std::endl;
        OnExecute();
        std::cout << "LOG: The task has completed - " << GetName() << std::endl;
    }
 
    virtual void OnExecute() = 0;
};
 
// Concrete Task implementation that reuses the logging code of the BaseLoggingTask
class MyTask : public BaseLoggingTask {
public:
    void OnExecute() override {
        std::cout << "...This is where the task is executed..." << std::endl;
    }
 
    std::string GetName() override {
        return "My task name";
    }
};

// abstract base class which implements Execute() and provides task timing feature.  Derived classes must implement OnExecute().
class BaseTimingTask : public ITask {
    Timer mTimer;
public:
    void Execute() override {
        mTimer.Reset();
        OnExecute();
        double t = mTimer.GetElapsedTimeSecs();
        std::cout << "Task Duration: " << t << " seconds" << std::endl;
    }
 
    virtual void OnExecute() = 0;
};
 
// Concrete Task implementation that reuses the timing code of the BaseTimingTask
class MyTask : public BaseTimingTask {
public:
    void OnExecute() override {
        std::cout << "...This is where the task is executed..." << std::endl;
    }
 
    std::string GetName() override {
        return "My task name";
    }
};

class LoggingTask : public ITask {
    std::unique_ptr<ITask> mTask;
public:
    explicit LoggingTask(ITask* task) : mTask(task) {}
 
    void Execute() override {
        std::cout << "LOG: The task is starting - " << GetName() << std::endl;
        if (mTask) mTask->Execute();
        std::cout << "LOG: The task has completed - " << GetName() << std::endl;
    }
 
    std::string GetName() override {
        if (mTask) {
            return mTask->GetName();
        } else {
            return "Unbound LoggingTask";
        }
    }
};

class TimingTask : public ITask {
    std::unique_ptr<ITask> mTask;
    Timer mTimer;
public:
    explicit TimingTask(ITask* task) : mTask(task) {}
 
    void Execute() override {
        mTimer.Reset();
        if (mTask) mTask->Execute();
        double t = mTimer.GetElapsedTimeSecs();
        std::cout << "Task Duration: " << t << " seconds" << std::endl;
    }
 
    std::string GetName() override {
        if (mTask) {
            return mTask->GetName();
        } else {
            return "Unbound TimingTask";
        }
    }
};

// MyTask is written with no coupling to the reusable logging and timing task
class MyTask : public ITask {
public:
    void Execute() override {
        std::cout << "...This is where the task is executed..." << std::endl;
    }
 
    std::string GetName() override {
        return "My task name";
    }
};
 
// Add timing and logging to MyTask through composition and delegation
std::unique_ptr<Itask> t(new LoggingTask(new TimingTask(new MyTask())));
t->Execute();

class MyTask : public ITask {
public:
    void Execute() override {
        std::cout << "...This is where the task is executed..." << std::endl;
    }
 
    std::string GetName() override {
        return "My task name";
    }
};

class TimingTask : public MyTask {
protected:
    void Execute() override {
        std::cout << "(start timer)" << std::endl;
        MyTask::Execute();
        std::cout << "(end timer)" << std::endl;
    }
};

class LoggingTask : public TimingTask {
protected:
    void Execute() override {
        std::cout << "LOG: The task is starting: " << GetName() << std::endl;
        TimingTask::Execute();
        std::cout << "LOG: The task has completed: " << GetName() << std::endl;
    }
};

template <typename T>
class MyMixin : public T {};

template <typename T>
class LoggingTask : public T {
public:
    void Execute() {
        std::cout << "LOG: The task is starting - " << GetName() << std::endl;
        T::Execute();
        std::cout << "LOG: The task has completed - " << GetName() << std::endl;
    }
};

template <typename T>
class TimingTask : public T {
    Timer mTimer;
public:
    void Execute() {
        mTimer.Reset();
        T::Execute();
        double t = mTimer.GetElapsedTimeSecs();
        std::cout << "Task Duration: " << t << " seconds" << std::endl;
    }
};
 
class MyTask {
public:
    void Execute() {
        std::cout << "...This is where the task is executed..." << std::endl;
    }
 
    std::string GetName() {
        return "My task name";
    }
};

// A plain old MyTask
MyTask t1;
t1.execute();
 
// A MyTask with added timing:
TimingTask<MyTask> t2;
t2.Execute();
 
// A MyTask with added logging and timing:
LoggingTask<TimingTask<MyTask>> t3;
t3.Execute();
 
// A MyTask with added logging and timing written to look a bit like the composition example
typedef LoggingTask<TimingTask<MyTask>> Task;
Task t4;
t4.Execute();

template <typename T>
class TaskAdapter : public ITask, public T {
public:
    void Execute() override {
        T::Execute();
    }
 
    std::string GetName() override {
        return T::GetName();
    }
};

// typedef for our final class, inlcuding the TaskAdaTpter<> mixin
typedef TaskAdapter<LoggingTask<TimingTask<MyTask>>> ask;
 
// instance of our Task - note that we are not forced into any heap allocations!
Task t;
 
// implicit conversion to ITask* thanks to the TaskAdapter<>
ITask* it = &t;
it->Execute();

template <typename Base> 
class Printing : public Base {...};

class Customer {
public:
    Customer(const char* fn, const char* ln)
        : mFirstName(fn), mLastName(ln) {}
    void Print() const {
        cout << mFirstName
        << ' '
        << mLastName;
    }
private:
    const char* mFirstName,
    const char* mLastName;
};
 
template <typename Base>
class PhoneContact: public Base {
public:
    PhoneContact(const char* fn, const char* ln, const char* pn)
        : Base(fn,ln), mPhone(pn) {}
    void Print()() const {
        Base::Print();
        cout << ' ' << mPhone;
    }
private:
    const char* mPhone;
};
 
template <typename Base>
class EmailContact: public Base {
public:
    EmailContact(const char* fn, const char* ln, const char* e)
        : Base(fn,ln),mEmail(e) {}
    void Print() const {
        Base::Print();
        cout << ' ' << mEmail;
    }
private:
    const char* mEmail;
};
 
int main() {
    Customer c1("Teddy","Bear");
    c1.Print(); cout << endl;
    PhoneContact<Customer> c2("Rick","Racoon","050-998877");
    c2.Print(); cout << endl;
    EmailContact<Customer> c3("Dick","Deer","dick@deer.com");
    c3.Print(); cout << endl;
    // The following composition isn't legal because there
    // is no constructor that takes all four arguments.
    // EmailContact<PhoneContact<Customer> >
    // c4("Eddy","Eagle","049-554433","eddy@eagle.org");
    // c4.Print(); cout << endl;
    return 0;
}

class Customer {
public:
    Customer(const char* fn, const char* ln)
        : mFirstName(fn), mLastName(ln) {}
    void Print() const {
        cout << mFirstName
            << ' '
            << mLastName;
    }
private:
    const char* mFirstName,
    const char* mLastName;
};
 
// The new mixin class will be defined using multiple inheritance. 
// Therefore Base must be turned into a virtual base class.
template <typename Base>
class PhoneContact: virtual public Base {
public:
    PhoneContact(const char* fn, const char* ln, const char* pn)
        :Base(fn, ln), mPhone(pn) {}
    void Print() const {
        Base::Print();
        BasicPrint();
    }
protected:
    // We need an "inner" print method that prints the PhoneContact-specific
    // information only.
    void BasicPrint() const {
        cout << ' ' << mPhone;
    }
private:
    const char* mPhone;
};
 
// Base has to be declared as virtual base class here, too.
template <typename Base>
class EmailContact: virtual public Base {
public:
    EmailContact(const char* fn, const char* ln, const char* e)
        : Base(fn, ln), mEmail(e){}
    void Print() const {
        Base::Print();
        BasicPrint();
    }
protected:
    // We need an "inner" print method that prints the EmailContact-specific
    // information only.
    void BasicPrint() const {
        cout << ' ' << mEmail;
    }
private:
    const char* mEmail;
};
 
template <typename Base>
class PhoneAndEmailContact :
    public PhoneContact<Base>,
    public EmailContact<Base> {
public:
    // Because Base is a virtual base class, PhoneAndEmailContact is now 
    // responsible for its initialization.
    PhoneAndEmailContact(const char* fn, const char* ln, char* pn, const char* e)
        : PhoneContact<Base>(fn, ln, pn)
        , EmailContact<Base>(fn, ln, e)
        , Base(fn, ln) {}
    void Print() const {
        Base::Print();
        PhoneContact<Base>::BasicPrint();
        EmailContact<Base>::BasicPrint();
    }
};

// Define a class that wraps the union of all constructor arguments 
// of Customer and all derived mixin classes. 
 
// CustomerParameter combines all constructor arguments of CustomerParameter 
// and its derived mixin classes. The default values for the last two 
// arguments provide some convenience to the client programmer.
struct CustomerParameter {
    const char* fn,
    const char* ln,
    const char* pn,
    const char* e;
    CustomerParameter(
        const char* fn_,
        const char*ln_,
        const char* pn_ = "",
        const char* e_ = "")
        : fn(fn_), ln(ln_), pn(pn_), e(e_) {}
};
 
class Customer {
public:
    explicit Customer(const CustomerParameter& cp)
        : mFirstName(cp.fn), mLastName(cp.ln) {}
    void Print() const {
        cout << mFirstName
            << ' '
            << mLastName;
    }
private:
    const char* mFirstName,
    const char* mLastName;
};
 
template <typename Base>
class PhoneContact: public Base {
public:
    explicit PhoneContact(const CustomerParameter& cp)
        : Base(cp), mPhone(cp.pn) {}
    void Print() const {
        Base::Print();
        cout << ' ' << mPhone;
    }
private:
    const char* mPhone;
};
 
template <typename Base>
class EmailContact: public Base {
public:
    explicit EmailContact(const CustomerParameter& cp)
        : Base(cp), mEmail(cp.e) {}
    void Print() const {
        Base::Print();
        cout << ' ' << mEmail;  
    }
private:
    const char* mEmail;
};

// Define special intialization methods in each class and no longer rely 
// on the proper initialization though constructors.
 
class Customer {
public:
    // Initialization method for Customer.
    // A default constructor will be generated automatically.
    void init(const char* fn, const char* ln) {
        mFirstName = fn;
        mLastName = ln;
    }
    void Print() const {
        cout << mFirstName
            << ' '
            << mLastName;
    }
private:
    const char* mFirstName,
    const char* mLastName;
};
 
template <typename Base>
class PhoneContact: public Base {
public:
    // Initialization method for PhoneContact only.
    // A default constructor will be generated automatically.
    void init(const char* pn) {
        mPhone = pn;
    }

    void Print() const {
        Base::Print();
        cout << ' ' << mPhone;
    }
private:
    const char* mPhone;
};
 
template <typename Base>
class EmailContact: public Base {
public:
    // Initialization method for EmailContact only.
    // A default constructor will be generated automatically.
    void init(const char* e) {
        mEmail = e;
    }

    void Print() const {
        Base::Print();
        cout << ' ' << mEmail;
    }
private:
    const char* mEmail;
};

template <typename Base>
class PhoneContact: public Base {
public:
    // The following constructors will be instantiated only if required.
    PhoneContact(
        const char* fn,
        const char* ln,
        const char* pn)
        : Base(fn, ln), mPhone(pn) {}
    PhoneContact(
        const char* fn,
        const char* ln,
        const char* pn,
        const char* e)
        :Base(fn, ln, e), mPhone(pn) {}
    void Print() const {
        Base::Print();
        cout << ' ' << mPhone;
    }
private:
    const char* mPhone;
};
 
template <typename Base>
class EmailContact: public Base {
public:
    // The following constructors will be instantiated only if required.
    EmailContact(
        const char* fn,
        const char* ln,
        const char* e)
        : Base(fn, ln), mEmail(e) {}
    EmailContact(
        const char* fn,
        const char* ln,
        const char* pn,
        const char* e)
        : Base(fn, ln, pn), mEmail(e) {}
    void Print() const {
        Base::Print();
        cout << ' ' << mEmail;
    }
private:
    const char* mEmail;
};

struct NIL {};
template <typename Head_, typename Tail_ = NIL>
struct List {
    typedef Head_ Head;
    typedef Tail_ Tail;

    List(const Head& h, const Tail& t = NIL())
        : mHead(h), mTail(t) {}

    Head mHead;
    Tail mTail;
};

List<signed char, List<short, List<int, List<long>>>>l(
    'a',
    List<short, List<int, List<long>>>(
        1,
        List<int, List<long>>(
            2,
            List<Long>(3))));

template <typename Config_>
class Customer {
public:
    typedef Config_ Config;
    typedef List<
        typename Config::LastnameType,
        List<typename Config::FirstnameType>> ParamType;
    explicit Customer(const ParamType& p)
        : mFirstName(p.mTail.mHead), mLastName(p.mHead) {}
    void Print() const {
        cout << mFirstName
            << ' '
            << mLastName;
    }
private:
    typename Config::FirstnameType mFirstName;
    typename Config::LastnameType mLastName;
};

template <typename Base>
class PhoneContact: public Base {
public:
    typedef typename Base::Config Config;
    typedef List<
        typename Config::PhoneNoType,
        typename Base::ParamType> ParamType;
    explicit PhoneContact(const ParamType& p)
        :Base(p.mTail), mPhone(p.mHead) {}
    void Print() const {
        Base::Print();
        cout << ' ' << mPhone;
    }
private:
    typename Config::PhoneNoType mPhone;
};

template <typename Base>
class EmailContact: public Base {
public:
    typedef typename Base::Config Config;
    typedef List<
        typename Config::EmailAddressType,
        typename Base::ParamType> ParamType;
    explicit EmailContact(const ParamType& p)
        :Base(p.mTail), mEmail(p.mHead) {}
    void Print() const {
        Base::Print();
        cout << ' ' << mEmail;
    }
private:
    typename Config::EmailAddressType mEmail;
};

template <typename Base>
struct ParameterAdapter: Base {
    typedef typename Base::Config Config;

    typedef typename Config::RET::ParamType P;
    typedef typename P::N P1;
    typedef typename P1::N P2;

    template <typename A1>
    explicit ParameterAdapter(const A1& a1) 
        : Base(a1) {}

    template <typename A1, typename A2>
    ParameterAdapter(const A1& a1, const A2& a2)
        : Base(P(a2,a1)) {}

    template <typename A1, typename A2, typename A3>
    ParameterAdapter(const A1& a1, const A2& a2, const A3& a3)
        : Base(P(a3,P1(a2,a1))) {}

    template <typename A1, typename A2, typename A3, typename A4>
    ParameterAdapter(
        const A1& a1,
        const A2& a2,
        const A3& a3,
        const A4& a4)
        : Base(P(a4,P1(a3,P2(a2,a1)))) {}
};
 
struct C1 {
    typedef C1 ThisConfig;

    typedef const char* FirstnameType;
    typedef const char* LastnameType;

    typedef Customer<ThisConfig> CustomerType;

    typedef ParameterAdapter<CustomerType> RET;
};
 
struct C2 {
    typedef C2 ThisConfig;

    typedef const char* FirstnameType;
    typedef const char* LastnameType;
    typedef const char* PhoneNoType;

    typedef Customer<ThisConfig> CustomerType;
    typedef PhoneContact<CustomerType> PhoneContactType;

    typedef ParameterAdapter<PhoneContactType> RET;
};
 
struct C3 {
    typedef C3 ThisConfig;

    typedef const char* FirstnameType;
    typedef const char* LastnameType;
    typedef const char* EmailAddressType;

    typedef Customer<ThisConfig> CustomerType;
    typedef EmailContact<CustomerType> EmailContactType;

    typedef ParameterAdapter<EmailContactType> RET;
};

struct C4 {
    typedef C4 ThisConfig;

    typedef const char* FirstnameType;
    typedef const char* LastnameType;
    typedef const char* PhoneNoType;
    typedef const char* EmailAddressType;

    typedef Customer<ThisConfig> CustomerType;
    typedef PhoneContact<CustomerType> PhoneContactType;
    typedef EmailContact<PhoneContactType> EmailContactType;

    typedef ParameterAdapter<EmailContactType> RET;
};

C1::RET c1("Teddy","Bear");
c1.Print(); cout << endl;
C2::RET c2("Rick","Racoon","050-998877");
c2.Print(); cout << endl;
C3::RET c3("Dick","Deer","dick@deer.com");
c3.Print(); cout << endl;
C4::RET c4("Eddy","Eagle","049-554433","eddy@eagle.org");
c4.Print(); cout << endl;

template <typename T>
class Base {
    ...
};

class Derived : public Base<Derived> {
    ...
};

class Base {
public:
    ...
    virtual int Foo() = 0;
};

class Derived : public Base {
public:
    ...
    int Foo() override;
};

void Func(Base& b) {
    cout << b.Foo() << endl;
}

template <typename T>
class Base {
public:
    ...
    int Foo() {
        return static_cast<T*>(this)->Foo();
    }
};

class Derived : public Base<Derived> {
public:
    ...
    int Foo();
};

template <typename T>
class Repeatable {
public:
    void Repeat(int n) const {
        for (int i = 0; i < n; ++i) {
            static_cast<const T*>(this)->Foo();
        }
    }
};

class ZeroPrinter : public Repeatable<ZeroPrinter> {
public:
    void Foo() const {
        cout << "0";
    }
};

class RepeatableZeroPrinter: public ZeroPrinter, public Repeatable<RepeatableZeroPrinter> {
};

template <typename T>
struct Counter {
    static int mObjectsCreated;
    static int mObjectsAlive;

    Counter() {
        ++mObjectsCreated;
        ++mObjectsAlive;
    }
    
    Counter(const Counter&) {
        ++mObjectsCreated;
        ++mObjectsAlive;
    }
protected:
    // objects should never be removed through pointers of this type
    ~Counter() {
        --mObjectsAlive;
    }
};
template <typename T> int Counter<T>::mObjectsCreated(0);
template <typename T> int Counter<T>::mObjectsAlive(0);

class X : Counter<X> {
    // ...
};

class Y : Counter<Y> {
    // ...
};

class Printer {
public:
    explicit Printer(ostream& pstream) : mStream(pstream) {}

    template <typename T>
    Printer& Print(T&& t) {
        mStream << t;
        return *this;
    }

    template <typename T>
    Printer& Println(T&& t) {
        mStream << t << endl;
        return *this;
    }
private:
    ostream& mStream;
};

Printer{myStream}.Println("hello").Println(500);

class CoutPrinter : public Printer {
public:
    CoutPrinter() : Printer(cout) {}

    CoutPrinter& SetConsoleColor(Color c) { ... return *this; }
};

// Base class
template <typename ConcretePrinter>
class Printer {
public:
    explicit Printer(ostream& pstream) : mStream(pstream) {}

    template <typename T>
    ConcretePrinter& Print(T&& t)
    {
        mStream << t;
        return static_cast<ConcretePrinter&>(*this);
    }

    template <typename T>
    ConcretePrinter& Println(T&& t)
    {
        mStream << t << endl;
        return static_cast<ConcretePrinter&>(*this);
    }
private:
    ostream& mStream;
};
 
// Derived class
class CoutPrinter : public Printer<CoutPrinter> {
public:
    CoutPrinter() : Printer(cout) {}

    CoutPrinter& SetConsoleColor(Color c) { ... return *this; }
};
 
// usage
CoutPrinter().Print("Hello ").SetConsoleColor(Color.red).Println("Printer!");

// Base class has a pure virtual function for cloning
class Shape {
public:
    virtual ~Shape() {}
    virtual Shape* Clone() const = 0;
};

// This CRTP class implements clone() for Derived
template <typename Derived>
class Shape_CRTP : public Shape {
public:
    Shape* Clone() const override {
        return new Derived(static_cast<Derived const&>(*this));
    }
};

class Square : public Shape_CRTP<Square> {
    ...
};

class Circle : public Shape_CRTP<Circle> {
    ...
};

template <typename T>
struct CRTP {
    T& Underlying() { return static_cast<T&>(*this); }
    T const& Underlying() const { return static_cast<T const&>(*this); }
};

emplate <typename T>
class Base : private CRTP<T>{
public:
    ...
    int Foo() {
        return this->Underlying().Foo();
    }
};

class Derived1 : public Base<Derived1> {
    ...
};
 
class Derived2 : public Base<Derived1> { // bug in this line of code
    ...
};

template <typename T>
class Base {
public:
    // ...
private:
    Base(){};
    friend T;
};

template <typename T>
struct Scalable : private CRTP<T> {
    void Scale(double multiplicator) {
        this->Underlying().SetValue(this->Underlying().GetValue() * multiplicator);
    }
};
 
template <typename T>
struct Squarable : private CRTP<T> {
    void Square() {
        auto v = this->Underlying().GetValue();
        this->Underlying().SetValue(v * v);
    }
};

class Sensitivity : public Scalable<Sensitivity>, public Squarable<Sensitivity> {
public:
    double GetValue() const { return mValue; }
    void SetValue(double value) { mValue = value; }
 
private:
    double mValue;
};

template <typename T, template <typename> class CrtpType>
struct CRTP {
    T& Underlying() { return static_cast<T&>(*this); }
    T const& Underlying() const { return static_cast<T const&>(*this); }
private:
    CRTP() {}
    friend CrtpType<T>;
};

// case 0
S s1(s0);
// case 1
S s2 = s0;
// case 2
void Func(S s3);
Func(s0);

s1 = s0;
s2 = GetTempS();

struct Base {
    Base(): x(0) {}
    Base(const Base& b): x(b.x) {}
    Base& operator=(const Base& b) {
        x = b.x;
    }
    int x;
};

struct Derived: public Base {
    Derived(): y(1) {}
    Derived(const Derived& d): y(d.y) {}
    Derived& operator=(const Derived& d) {
        y = d.y;
    }
    int y;
};

int main() {
    Derived d0;
    d0.x = 2;
    d0.y = 2;
    Derived d1 = d0;
    printf("%d %d\n", d1.x, d1.y);
    d1.x = 3;
    d1 = d0;
    printf("%d %d\n", d1.x, d1.y);
}

Derived::Derived(const Derived& d): Base(d), y(d.y) {}

Derived& Derived::operator=(const Derived& d) {
    Base::operator=(d);
    y = d.y;
}

class Widget {
    ...
private:
    Bitmap* pb;
};

Widget& Widget::operator=(const Widget& rhs) {
    delete pb;
    pb = new Bitmap(*rhs.pb);
    return *this;
}

Widget& Widget::operator=(const Widget& rhs) {
    if (this != &rhs) {
        delete pb;
        pb = new Bitmap(*rhs.pb);
    }
    return *this;
}

Widget& Widget::operator=(const Widget& rhs) {
    if (this != &rhs) {
        Bitmap* pOrig = pb;
        pb = new Bitmap(*rhs.pb);
        delet pOrig;
    }
    return *this;
}

Widget& Widget::operator=(const Widget& rhs) {
    if (this != &rhs) {
        Widget tmp(rhs);
        swap(tmp);
    }
    return *this;
}

Widget& Widget::operator=(Widget rhs) {
    swap(rhs);
    return *this;
}

class Lock {
    ...
private:
    Lock(const Lock&);
    Lock& operator=(const Lock&);
};

class Lock {
public:
    Lock(const Lock&) = delete;
    Lock& operator=(const Lock&) = delete;
    ...
}

struct Base {
    virtual ~Base() {}
    virtual Base& operator=(const Base& b);
};

struct Derived: public Base {
    virtual Derived& operator=(const Derived& d);
}

int main() {
    Base* p0 = new Derived();
    Base* p1 = new Derived();
    *p0 = *p1;
}