依赖名与 typename / template 关键字

template <typename T>
void f() {
    typename T::value_type x;   // T::value_type 是类型
    T::static_value;            // T::static_value 是静态成员（值）
    obj.template method<T>();   // method 是成员模板
}

#include <iostream>
#include <vector>
#include <map>
#include <type_traits>

// ====== 场景 1：容器迭代器的嵌套类型 ======

template <typename Container>
void print_first_element(const Container& c) {
    if (c.empty()) return;

    // typename 必须：Container::const_iterator 是依赖类型
    typename Container::const_iterator it = c.begin();
    std::cout << "第一个元素: " << *it << std::endl;
}

// ====== 场景 2：返回类型中的依赖类型 ======

template <typename Container>
typename Container::value_type
get_last(const Container& c) {
    if (c.empty()) return typename Container::value_type{};
    return *(--c.end());
}

// ====== 场景 3：模板元编程中的类型萃取 ======

template <typename T>
struct TypeAnalyzer {
    // typename 用于依赖类型
    using ValueType = typename T::value_type;  // 假设 T 是容器

    // C++14 简化写法
    using ValueType14 = std::remove_const_t<typename T::value_type>;

    void print() {
        // typename 用于模板中的嵌套类型
        typename T::const_iterator it;

        std::cout << "分析容器类型..." << std::endl;
    }
};

// ====== template 消歧义：成员模板 ======

class Printer {
public:
    template <typename T>
    void print(const T& value) {
        std::cout << value << std::endl;
    }
};

template <typename P>
void test_template_keyword(P& printer) {
    // printer.print<int>(42) —— 编译器不知道 print 是模板
    // 在 "<" 被解析为小于号之前，需要 template 关键字

    printer.template print<int>(42);         // 正确
    printer.template print<double>(3.14);    // 正确
}

// ====== 综合场景：嵌套模板的复杂消歧义 ======

template <typename T>
class ContainerWrapper {
public:
    template <typename U>
    void process(const U& value) {
        // T::value_type 是依赖类型 → 需要 typename
        typename T::value_type local = static_cast<typename T::value_type>(value);
        std::cout << "处理值: " << local << std::endl;
    }
};

int main() {
    std::cout << "===== typename 消歧义 =====" << std::endl;

    std::vector<int> vec = {10, 20, 30, 40, 50};
    print_first_element(vec);
    std::cout << "最后一个元素: " << get_last(vec) << std::endl;

    std::map<int, std::string> m = {{1, "one"}, {2, "two"}};
    std::cout << "map 最后一个值: " << get_last(m).second << std::endl;

    std::cout << "\n===== template 消歧义 =====" << std::endl;
    Printer p;
    test_template_keyword(p);

    std::cout << "\n===== 嵌套模板消歧义 =====" << std::endl;
    ContainerWrapper<std::vector<int>> wrapper;
    wrapper.process(99);

    return 0;
}

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

// 通用排序函数——展示 typename 在真实代码中的使用
template <typename Iterator>
void sort_and_print(Iterator begin, Iterator end) {
    // std::iterator_traits<Iterator>::value_type 是依赖类型
    using ValueType = typename std::iterator_traits<Iterator>::value_type;

    std::sort(begin, end);

    std::cout << "排序后（类型: " << typeid(ValueType).name() << "）: ";
    for (Iterator it = begin; it != end; ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

// 累加函数——显式使用 value_type
template <typename Container>
typename Container::value_type  // typename 消歧义
accumulate_all(const Container& c) {
    typename Container::value_type sum{};  // typename 消歧义
    for (typename Container::const_iterator it = c.begin();  // typename
         it != c.end(); ++it) {
        sum += *it;
    }
    return sum;
}

int main() {
    std::vector<int> data = {3, 1, 4, 1, 5, 9};
    sort_and_print(data.begin(), data.end());

    std::cout << "累加和: " << accumulate_all(data) << std::endl;

    return 0;
}