1 模板方法模式简介
模板方法模式适用于需要在多个类中实现类似算法或流程的场景，但每个类具体实现细节可能不同的情况下。模板方法模式通过将算法或流程的主要骨架定义在一个抽象类中，以及定义一些可变的方法，让具体实现交由子类完成。
2 模板方法模式示例代码
#include <iostream>
#include <vector>
// 定义排序算法抽象类
class SortAlgorithm {
public:
virtual ~SortAlgorithm() {
}
// 模板方法
void Sort(std::vector<int>& arr) {
DoSort(arr);
Print(arr);
}
protected:
// 定义具体实现方法
virtual void DoSort(std::vector<int>& arr) = 0;
// 定义可变的方法，子类可以自己实现
virtual void Print(const std::vector<int>& arr) {
std::cout << "Sorted array: ";
for (auto i : arr) {
std::cout << i << " ";
}
std::cout << std::endl;
}
};
// 定义具体的排序算法类，实现 DoSort 方法
class BubbleSort : public SortAlgorithm {
protected:
virtual void DoSort(std::vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < n - i - 1; ++j) {
if (arr[j] > arr[j+1]) {
std::swap(arr[j], arr[j+1]);
}
}
}
}
};
// 定义具体的排序算法类，实现 DoSort 方法
class QuickSort : public SortAlgorithm {
protected:
virtual void DoSort(std::vector<int>& arr) {
QuickSortHelper(arr, 0, arr.size()-1);
}
private:
void QuickSortHelper(std::vector<int>& arr, int left, int right) {
if (left >= right) return;
int pivot = arr[left];
int i = left + 1;
int j = right;
while (i <= j) {
while (i <= j && arr[i] < pivot) ++i;
while (i <= j && arr[j] > pivot) --j;
if (i <= j) {
std::swap(arr[i], arr[j]);
++i;
--j;
}
}
std::swap(arr[left], arr[j]);
QuickSortHelper(arr, left, j-1);
QuickSortHelper(arr, j+1, right);
}
};
int main() {
std::vector<int> arr = {
3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
BubbleSort bubble_sort;
bubble_sort.Sort(arr);
std::vector<int> arr2 = {
3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
QuickSort quick_sort;
quick_sort.Sort(arr2);
return 0;
}
定义了一个排序算法的抽象类 SortAlgorithm，其中包含一个模板方法 Sort()，该方法定义了排序算法的主要骨架，并调用了一个叫做 Print() 的可变方法，该方法的默认实现输出排序后的结果。子类只需要实现具体的排序算法，即 DoSort() 方法，就可以通过调用 Sort() 方法来完成排序，并且可以自定义 Print() 方法的实现来满足不同的需求。
在示例代码中，我们定义了 BubbleSort 和 QuickSort 两个具体的排序算法类，它们分别继承 SortAlgorithm 类，并实现了 DoSort() 方法。在 main() 函数中，我们分别创建了 BubbleSort 和 QuickSort 的实例，并调用它们的 Sort() 方法完成排序。
可以看到，通过使用模板方法模式，我们可以将排序算法的主要骨架和具体实现分离开来，使得我们可以方便地在不同的子类中实现具体的排序算法，并且可以在抽象类中定义一些可变的方法，使得子类可以根据需要自定义实现，从而更好地满足不同的需求。
3 多传感器场景模板方法模式代码示例
假设我们有多个传感器，每个传感器都可以采集数据并进行处理，最终将结果输出。使用模板方法模式可以将这些传感器的数据处理过程抽象出来，并定义一个通用的算法流程，同时允许每个传感器自定义数据的采集和处理方式。
以下是一个基于模板方法模式的多传感器数据处理示例代码：
#include <iostream>
#include <vector>
// 抽象传感器类
class Sensor {
public:
virtual ~Sensor() {
}
virtual void collectData() = 0;
virtual void processData() = 0;
virtual void outputResult() = 0;
// 模板方法，定义通用的算法流程
void process() {
collectData();
processData();
outputResult();
}
};
// 传感器 A
class SensorA : public Sensor {
public:
void collectData() override {
std::cout << "SensorA: Collecting data..." << std::endl;
// 采集数据的具体实现
}
void processData() override {
std::cout << "SensorA: Processing data..." << std::endl;
// 处理数据的具体实现
}
void outputResult() override {
std::cout << "SensorA: Outputting result..." << std::endl;
// 输出结果的具体实现
}
};
// 传感器 B
class SensorB : public Sensor {
public:
void collectData() override {
std::cout << "SensorB: Collecting data..." << std::endl;
// 采集数据的具体实现
}
void processData() override {
std::cout << "SensorB: Processing data..." << std::endl;
// 处理数据的具体实现
}
void outputResult() override {
std::cout << "SensorB: Outputting result..." << std::endl;
// 输出结果的具体实现
}
};
int main() {
std::vector<Sensor*> sensors = {
new SensorA(), new SensorB()};
for (auto sensor : sensors) {
sensor->process(); // 调用模板方法
std::cout << std::endl;
}
for (auto sensor : sensors) {
delete sensor;
}
return 0;
}
在这个示例中，我们首先定义了一个抽象的传感器类 Sensor，其中包含三个纯虚函数 collectData()、processData() 和 outputResult()，分别用于采集数据、处理数据和输出结果。接下来，我们定义了两个具体的传感器类 SensorA 和 SensorB，分别继承了 Sensor 类，并实现了相应的虚函数。
在 main() 函数中，我们定义了一个包含多个传感器指针的 vector，并将 SensorA 和 SensorB 的实例添加到 vector 中。然后，我们遍历这个 vector，并依次调用每个传感器的 process() 方法，即通用的算法流程，这个方法内部调用了 collectData()、processData() 和 outputResult() 三个虚函数，其中 collectData() 和 processData() 的具体实现由每个传感器自己定义，而 outputResult() 的实现是相同的。这样，每个传感器都可以自定义数据的采集和处理方式，同时使用了通用的算法流程，避免了重复的代码。
总的来说，模板方法模式适用于以下场景：
在一个算法中，有一些步骤是相同的，而另一些步骤是可变的，需要在子类中进行具体实现。
需要将具体实现细节从算法中抽象出来，让算法更加简洁。
多个类具有相同的算法流程，但每个类的实现细节不同。
在多传感器数据处理的场景中，使用模板方法模式可以将每个传感器的数据处理过程抽象出来，并定义一个通用的算法流程，同时允许每个传感器自定义数据的采集和处理方式，减少了代码冗余，并提高了代码的可读性和可维护性。