设计模式---行为类型---模板方法

1、意图

定义一个操作中的算法骨架，而将一些步骤延迟到子类中。TemplateMethod使得子类可以不改变一个算法的结构可重定义该算法的某些特定步骤。

2、适用性

模板方法应用于下列情况：

1）一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

2）各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。

3）控制子类扩展。模板方法只在特定调用“hook”操作，这样就只允许在这些点进行扩展。

3、C++实例

// Test.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <Windows.h>
#include <list>
#include <string>

using namespace std;


 // 抽象类，定义冒泡排序的骨架
class BubbleSorter
{

public:

	// 冒泡排序算法
	int DoSort()
	{
		if ( _length <= 1 )
		{
			return _operations;
		}

		for ( int nextToLast = _length - 2; nextToLast >= 0; nextToLast-- )
		{
			for ( int index = 0; index <= nextToLast; index++ )
			{
				if ( OutOfOrder( index ))
				{
					Swap( index );
				}
				_operations++;
			}
		}

		return _operations;
	}

protected:

	BubbleSorter()
	{
		_operations = 0;
		_length = 0;
	}

	// 留给子类实现的交换位置方法
	virtual void Swap( int index ) = 0;

	// 留给子类实现的比较方法
	virtual bool OutOfOrder( int index ) = 0;

private:

	int _operations ;

protected:

	int _length ;
};


 // 整型类型的冒泡算法实现
class IntBubbleSorter:BubbleSorter
{
public:

	IntBubbleSorter( )
	{
		_array = NULL;
		_length = 0;
	}

	~IntBubbleSorter()
	{
		
	}

	int Sort( int* array, int length )
	{
		if ( NULL ==  array || 0 == length )
		{
			return -1;
		}

		_length = length;
		_array = array;
		// 调用冒泡算法
		return DoSort();
	}

protected:

	// 实现冒泡算法中的交换操作
	void Swap( int index )
	{
		int temp =  _array[index];
		_array[index] = _array[index+1];
		_array[index+1] = temp;
	}

	// 实现冒泡算法中的比较操作
	bool OutOfOrder( int index )
	{
		return ( _array[index] > _array[index+1] );
	}

private:

	int *_array;

};


// 浮点类型的冒泡算法实现
class DoubleBubbleSorter:BubbleSorter
{
public:

	DoubleBubbleSorter( )
	{
		_array = NULL;
		_length = 0;
	}

	~DoubleBubbleSorter()
	{

	}

	int Sort( double* array, int length )
	{
		if ( NULL ==  array || 0 == length )
		{
			return -1;
		}

		_length = length;
		_array = array;
		// 调用冒泡算法
		return DoSort();
	}

protected:

	// 实现冒泡算法中的交换操作
	void Swap( int index )
	{
		double temp =  _array[index];
		_array[index] = _array[index+1];
		_array[index+1] = temp;
	}

	// 实现冒泡算法中的比较操作
	bool OutOfOrder( int index )
	{
		return ( _array[index] > _array[index+1] );
	}

private:

	double *_array;

};
int _tmain(int argc, _TCHAR* argv[])
{
	int intArray[5] ={5, 3, 12, 8, 10};
	IntBubbleSorter* intsorter = new IntBubbleSorter;
	intsorter->Sort( intArray, 5);
	for (int i = 0 ; i < 5; i++ )
	{
		cout<<intArray[i]<<" ";
	}
	cout<<" int sort "<<endl;


	double doubleArray[5] ={3.2, 3.0, 2.9, 3.111, 3.1111};
	DoubleBubbleSorter* doublesorter = new DoubleBubbleSorter;
	doublesorter->Sort( doubleArray, 5);
	for (int i = 0 ; i < 5; i++ )
	{
		cout<<doubleArray[i]<<" ";
	}
	cout<<" float sort "<<endl;
	
	return 0;
}