设计模式---行为类型---模板方法
2016-07-30 22:35
417 查看
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;
}
定义一个操作中的算法骨架,而将一些步骤延迟到子类中。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;
}
相关文章推荐
- java23中设计模式——行为模式——Template(模板方法)
- Java设计模式(16)——行为模式之模板方法模式(Template)
- Java 设计模式之模板方法模式的详解(行为模式)
- 【设计模式基础】行为模式 - 6 - 模板方法(Template Method)
- 设计模式--模板方法模式(行为类模式)
- 【设计模式学习笔记二十四】【行为模式】【模板方法(Template Method)】
- 设计模式-行为-模板方法
- 字段不存在多态特征,代码块 ,final修饰符 ,单例设计模式 工具类的设计,基本类型包装类 ,抽象方法和抽象类 ,模板方法设计模式
- 【设计模式】行为模式之Template Method模板方法
- 设计模式-行为设计模式:模板方法设计模式 TemplateMethod
- 设计模式行为模式(模板方法模式)
- 设计模式之行为模式-命令,迭代器,中介者,观察者,模板方法
- 设计模式二十三:template method(模板方法)——类行为模式
- 行为设计模式---模板方法模式(Template Method)
- 深入浅出Java模式设计之模板方法模式
- 设计模式学习笔记(十六)——Template Method模板方法模式
- 设计模式--模板方法模式(照旧,有类关系图)
- 设计模式一模板方法模式(spring)
- 设计模式笔记(十五) —— 模板方法模式
- 解读设计模式----模板方法模式(Template Method),电脑就是这样造出来的