/* sort.h */
#ifndef _SORT_H_
#define _SORT_H_

#include <stdbool.h>

class Sort
{
public:
	virtual ~Sort();
	virtual void Swap(int)=0;	/* Interactive data */
	virtual bool Judge(int)=0;  /* Data judgment method (sorting method)*/
	void SortRun();				/* Sorting algorithm framework */
protected:
	Sort();
    int m_Size;
};
#endif

• The second step is to implement the abstract class Sort method

/* sort.cpp */
#include "sort.h"

Sort::Sort()
{
	m_Size = 0;
}

Sort::~Sort()
{
}

void Sort::SortRun()
{
	int i = 0,j = 0;

	for (j=0; j<m_Size-1; j++)
	{
		for (i=0; i<m_Size-1-j; i++)
		{
			if (Judge(i))
			{
				Swap(i);
			}
		}
	}
}

• Step 3: declare the integer data sorting subclass InstSort to inherit the abstract parent class

/* int_sort.h */
#ifndef _INT_SORT_H_
#define _INT_SORT_H_

#include <stdbool.h>
#include "sort.h"

class IntSort:public Sort
{
public:
	IntSort();
	virtual ~IntSort();

	void Swap(int);		/* Rewrite int data interaction method */
	bool Judge(int);	/* Judgment method of rewriting int data */
	void SortData(int*, int);
private:
	int *m_pArray;
};
#endif

• Step 4: implement the InstSort method of integer data sorting subclass to realize the sorting data type and sorting method

/* int_sort.cpp */

#include <iostream>
#include "int_sort.h"

using namespace std;

IntSort::IntSort()
{
}

IntSort::~IntSort()
{
}

void IntSort::Swap(int index)
{
	int temp;
	
	temp = m_pArray[index];
    m_pArray[index] = m_pArray[index+1];
    m_pArray[index+1] = temp;
}

bool IntSort::Judge(int index)
{
	return m_pArray[index] > m_pArray[index+1];	/* Sort from small to large */
}

void IntSort::SortData(int *array, int size)
{
	this->m_pArray = array;
	this->m_Size = size;
	this->SortRun();

	cout<<"int Sort type data from small to large: ";
	for(int i = 0; i < m_Size; i++)
	{
		cout << m_pArray[i] << " ";	
	}
	cout<<endl;
}

• Step 5: declare the single precision floating-point data sorting subclass FloatSort to inherit the abstract parent class

/* float_insort.h */

#ifndef _FLOAT_SORT_H_
#define _FLOAT_SORT_H_

#include <stdbool.h>
#include "sort.h"

class FloatSort:public Sort
{
public:
	FloatSort();
	virtual ~FloatSort();

	void Swap(int);		/* Rewriting float data interaction method */
	bool Judge(int);	/* Rewriting float data judgment method */
	void SortData(float*, int);
private:
	float *m_pArray;
};
#endif

• Step 6: the single precision floating-point data sorting subclass FloatSort method is implemented to realize the sorting data type and sorting mode

/* float_sort.cpp */

#include <iostream>
#include "float_sort.h"

using namespace std;

FloatSort::FloatSort()
{
}

FloatSort::~FloatSort()
{
}

void FloatSort::Swap(int index)
{
	float temp;
	
	temp = m_pArray[index];
    m_pArray[index] = m_pArray[index+1];
    m_pArray[index+1] = temp;
}

bool FloatSort::Judge(int index)
{
	return m_pArray[index] < m_pArray[index+1];	/* Sort from large to small */
}

void FloatSort::SortData(float *array, int size)
{
	this->m_pArray = array;
	this->m_Size = size;
	this->SortRun();

	cout<<"float Sort type data from large to small: ";
	for(int i = 0; i < m_Size; i++)
	{
		cout << m_pArray[i] << " ";	
	}
	cout<<endl;
}

• Step 7: the customer calls different subclass objects to realize the specified sorting function

/* client.cpp */
#include "sort.h"
#include "int_sort.h"
#include "float_sort.h"

int main(int argc, char **arv)
{
	int intArray[] = {1, 0, 3, 2, 5, 4, 7};
    int size = sizeof intArray / sizeof intArray[0];
    IntSort *intSort = new IntSort;
    intSort->SortData(intArray, size);
	delete intSort;

	float flaotArray[] = {1.0, 0.3, 1.2, 1.1, 5.4, 2.5, 3.3};
    size = sizeof flaotArray / sizeof flaotArray[0];
    FloatSort *floatSort = new FloatSort;
    floatSort->SortData(flaotArray, size);
	delete floatSort;
}

• The last step is to write the Makefile file

VERSION 	=1.00
CC			=g++
DEBUG 		=
CFLAGS		=-Wall
SOURCES	 	=$(wildcard *.cpp)
INCLUDES  	=
LIB_NAMES 	=
LIB_PATH 	=
OBJ			=$(patsubst %.cpp, %.o, $(SOURCES))
TARGET		=client

#links
$(TARGET):$(OBJ)
	@mkdir -p output
	$(CC) $(OBJ) $(LIB_PATH) $(LIB_NAMES) -o output/$(TARGET)$(VERSION)
	@rm -rf $(OBJ)
	
#compile
%.o: %.c
	$(CC) $(INCLUDES) $(DEBUG) -c $(CFLAGS) $< -o $@

.PHONY:clean
clean:
	@echo "Remove linked and compiled files......"
	rm -rf $(OBJ) $(TARGET) output 

Execution results:

acuity@ubuntu:/mnt/hgfs/LSW/STHB/design/template$ make
g++    -c -o float_sort.o float_sort.cpp
g++    -c -o int_sort.o int_sort.cpp
g++    -c -o client.o client.cpp
g++    -c -o sort.o sort.cpp
g++  float_sort.o  int_sort.o  client.o  sort.o   -o output/client1.00
acuity@ubuntu:/mnt/hgfs/LSW/STHB/design/template$ ls
client.cpp  float_sort.cpp  float_sort.h  int_sort.cpp  int_sort.h  Makefile  Makefile.bak  output  sort.cpp  sort.h
acuity@ubuntu:/mnt/hgfs/LSW/STHB/design/template$ ./output/client1.00 
int Sort type data from small to large: 0 1 2 3 4 5 7 
float Sort type data from large to small: 5.4 3.3 2.5 1.2 1.1 1 0.3 

6 Comparison between template mode and policy mode

6.1 comparison of differences

Similarities:

   both are flexible use of algorithms.

difference:

• The template pattern is more important than stripping the algorithm steps. The common part is implemented by the abstract parent class, and the difference part is delayed to the child class. It is an algorithm
• The strategy mode focuses on multiple algorithms that can be replaced with each other without affecting customers' use. It is aimed at multiple algorithms

   for example, for the above algorithm examples, the template mode decomposes a sorting algorithm into several steps, delays the difference step to the subclass implementation, and the sorting and sorting types of different types of data are implemented by the subclass. For the policy mode, this may be considered. A variety of sorting algorithms, such as bubble sorting, selection sorting, insertion sorting and so on, can be switched and selected freely.

6.2 advantages, disadvantages and application scenario selection

Comparison of advantages and disadvantages:

Scene selection

   template mode and strategy mode have their own advantages and disadvantages. The choice of which mode is an important and difficult one, which needs to be made according to the comprehensive consideration of specific business functions, function expansibility, industry characteristics and their own design experience. You can refer to the following choices.