C++ 模板专题 - 标签分派(Tag Dispatching)

一：概述:

        在 C++ 中，Tag Dispatching 是一种编程技巧，主要用于在编译期根据不同的类型或特征选择不同的函数重载或代码分支。Tag Dispatching 借助类型标签（tags）进行函数调度，用于在模板中实现编译期的静态分派。这种方法特别适合在泛型编程中根据类型特性（如迭代器类型、数据结构特性等）选择特定的操作路径。

二：工作原理：

Tag Dispatching 通常通过以下几步实现：

1. 定义标签类型：定义标签结构类型（tag classes），这些标签不含数据，只用于标识类型特性。通常通过继承或者 struct 定义。

2. 重载函数：定义多组重载函数，每个重载函数接受特定的标签类型，基于标签进行特定操作。

3. 选择合适的标签：编写一个主函数或模板函数，通过类型萃取或特征检测，选择合适的标签类型并传递给对应的重载函数。

三:例子：

#include <iostream>
#include <vector>
#include <list>
#include <type_traits>

// 定义标签类型
struct RandomAccessIteratorTag {};
struct BidirectionalIteratorTag {};

// 重载函数，根据不同的标签类型执行不同的逻辑
template <typename Iterator>
void process(Iterator it, RandomAccessIteratorTag) {
    std::cout << "Processing a random access iterator.\n";
}

template <typename Iterator>
void process(Iterator it, BidirectionalIteratorTag) {
    std::cout << "Processing a bidirectional iterator.\n";
}

// 主函数，选择适当的标签类型并调用相应的重载函数
template <typename Container>
void process(Container& container) {
    using IteratorType = typename Container::iterator;

    // 选择标签类型
    if constexpr (std::is_same_v<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>) {
        process(container.begin(), RandomAccessIteratorTag{});
    } else {
        process(container.begin(), BidirectionalIteratorTag{});
    }
}

int main() {
    std::vector<int> vec = {1, 2, 3};
    std::list<int> lst = {4, 5, 6};

    process(vec); // 输出：Processing a random access iterator.
    process(lst); // 输出：Processing a bidirectional iterator.

    return 0;
}

#include <iterator>
#include <forward_list>
#include <list>
#include <vector>
#include <iostream>

template <typename InputIterator, typename Distance>
void advance_impl(InputIterator& i, Distance n, std::input_iterator_tag) {
	std::cout << "InputIterator used" << '\n'; 
    while (n--) ++i;
}

template <typename BidirectionalIterator, typename Distance>
void advance_impl(BidirectionalIterator& i, Distance n, std::bidirectional_iterator_tag) {
	std::cout << "BidirectionalIterator used" << '\n';
    if (n >= 0) 
        while (n--) ++i;
    else 
        while (n++) --i;
}

template <typename RandomAccessIterator, typename Distance>
void advance_impl(RandomAccessIterator& i, Distance n, std::random_access_iterator_tag) {
	std::cout << "RandomAccessIterator used" << '\n';
    i += n;
}

template <typename InputIterator, typename Distance>
void advance_(InputIterator& i, Distance n) {
    typename std::iterator_traits<InputIterator>::iterator_category category;    
    advance_impl(i, n, category);                                                
}
  
int main(){
    
}

 四：应用场景：

• 容器适配器：为不同类型的容器（如 std::vector、std::list）或迭代器实现不同的处理逻辑。
• 算法优化：根据不同数据类型，选择更适合的实现，以提升算法的效率。
• 类型特性区分：如分派不同的指针类型、智能指针类型，或根据类型特性选择最佳实现。

五：优点：

• 高效的编译期选择：通过标签选择合适的重载函数，可以在编译期确定不同路径，无需运行时判断。
• 代码复用和扩展性：通过重载函数和标签类型，可以在不修改原有代码的情况下支持新的类型。