Design Patterns: Template mode (template)

Template pattern template

Template pattern summarized in that the flow of traffic unitary extraction (abstract) out, designed to form a unified flow treatment class
whereby specific business logic and peeled off;

C ++ implementation

#include<iostream>
using namespace std;

class Process
{
public:
    Process() {}
    virtual ~Process() {}
    virtual void step1() {}
    virtual void step2() {}
    virtual void step3() {}

    void process()
    {
        step1();
        step2();
        step3();
    }
};

class WorkerA : public Process
{
public:
    WorkerA(){}
    virtual ~WorkerA(){}

    void step1() override {
        std::cout << "WorkerA::step1()......" << std::endl;
    }
    void step2() override {
        std::cout << "WorkerA::step2()......" << std::endl;
    }
    void step3() override {
        std::cout << "WorkerA::step3()......" << std::endl;
    }
};

class WorkerB : public Process 
{
public:
    WorkerB(){}
    virtual ~WorkerB(){}

    void step1() override {
        std::cout << "WorkerB::step1()......" << std::endl;
    }
    void step2() override {
        std::cout << "WorkerB::step2()......" << std::endl;
    }
    void step3() override {
        std::cout << "WorkerB::step3()......" << std::endl;
    }
};

void worker(Process* ps)
{
    ps->process();
}

int main()
{
    worker(new WorkerA());
    std::cout <<std::endl;
    worker(new WorkerB());
}

C implementation

#include<stdio.h>
#include<stdlib.h>

typedef struct _Process
{
    void *pData;
    void (*step1)(struct _Process* p);
    void (*step2)(struct _Process* p);
    void (*step3)(struct _Process* p);
    void (*process)(struct _Process* p);
}Process;

void process(Process* p)
{
    p->step1(p);
    p->step2(p);
    p->step3(p);
}

void WorkerA_Step1(Process* p)
{
    printf("WorkerA_Step1()......\n");
}

void WorkerA_Step2(Process* p)
{
    printf("WorkerA_Step2()......\n");
}

void WorkerA_Step3(Process* p)
{
    printf("WorkerA_Step3()......\n");
}

void WorkerB_Step1(Process* p)
{
    printf("WorkerB_Step1()......\n");
}

void WorkerB_Step2(Process* p)
{
    printf("WorkerB_Step2()......\n");
}

void WorkerB_Step3(Process* p)
{
    printf("WorkerB_Step3()......\n");
}

Process* WorkerCtor(void (*step1)(Process*),
                    void (*step2)(Process*),
                    void (*step3)(Process*))
{
    Process* ps = malloc(sizeof(Process));
    ps->step1 = step1;
    ps->step2 = step2;
    ps->step3 = step3;
    ps->process = process;
}

int main()
{
    Process* WorkerA = WorkerCtor(WorkerA_Step1, 
                                  WorkerA_Step2, 
                                  WorkerA_Step3);

    Process* WorkerB = WorkerCtor(WorkerB_Step1, 
                                  WorkerB_Step2, 
                                  WorkerB_Step3);
    process(WorkerA);
    printf("\n");
    process(WorkerB);
}