萃取

萃取技术常规范例

使用固定萃取技术可以减少泛型类型的使用，通过某个类型，可以得到另外一个类型

# 使用固定萃取
#include <iostream>

using namespace std;

namespace _nmsp2 {
    template<typename T>
    struct SumFixedTraits;

    template<>
    struct SumFixedTraits<char> {
        using sumT = int;
    };

    template<>
    struct SumFixedTraits<int> {
        using sumT = __int64_t;
    };

    template<typename T>
    auto function(const T *begin, const T *end) {
        // 给进去一个类型T,返回一个类型sumT,这里使用的是固定萃取
        using sumT = typename SumFixedTraits<T>::sumT;
        sumT sum{};
        for (;;) {
            sum += (*begin);
            if (begin == end)
                break;
            ++begin;
        }

        return sum;
    }
}

int main() {
    std::cout << "Hello, World!" << std::endl; {
        int myintarray1[] = {10, 15, 20};
        int myintarray2[] = {100000000, 150000000, 2000000000};
        char mychararray[] = "abc";

        // 使用固定萃取技术的话就可以根据参数类型确定返回至类型，不用再多用一个指定返回值类型的泛型参数了
        cout << _nmsp2::function(&myintarray1[0], &myintarray1[2]) << endl;
        cout << _nmsp2::function(&myintarray2[0], &myintarray2[2]) << endl;
        cout << (int) (_nmsp2::function(&mychararray[0], &mychararray[2])) << endl;
    }

    return 0;
}

萃取技术迭代器范例

迭代器种类

迭代器总共分为5类

• 输出型迭代器 struct std::output_iterator_tag;
• 输入型迭代器 struct std::input_iterator_tag;
• 前向迭代器 struct std::forward_iterator_tag;
• 双向迭代器 struct std::bidirectional_iterator_tag;
• 随机访问迭代器 struct std::random_access_iterator_tag;

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

namespace _nmsp1 {
    void _display_category(std::input_iterator_tag cagy) {
        std::cout << "input_iterator_tag" << std::endl;
    }

    void _display_category(std::output_iterator_tag cagy) {
        std::cout << "output_iterator_tag" << std::endl;
    }

    void _display_category(std::forward_iterator_tag cagy) {
        std::cout << "forward_iterator_tag" << std::endl;
    }

    void _display_category(std::bidirectional_iterator_tag cagy) {
        std::cout << "bidirectional_iterator_tag" << std::endl;
    }

    void _display_category(std::random_access_iterator_tag cagy) {
        std::cout << "random_access_iterator_tag" << std::endl;
    }

    // 使用下面的模板函数，能够判断出容器使用的迭代器种类
    template<typename T>
    void display_category(T iter) {
        typename std::iterator_traits<T>::iterator_category cagy;  // 萃取机
        _display_category(cagy);
    }

}

int main() {
    std::cout << "Hello, World!" << std::endl;

    // 判断vector容器对应的迭代器种类
    _nmsp1::display_category(std::pmr::vector<int>::iterator());

    // 提取list容器对应的迭代器种类
    _nmsp1::display_category(std::pmr::list<int>::iterator());


    return 0;
}