QC++ / Qt 学习之路

模板与泛型编程

编写类型无关的模板代码并理解其编译机制

进阶第 9 / 48 章第一篇 · C++ 基础巩固

#模板不是"泛型擦除"

如果你熟悉 Java 泛型,请先忘掉它的一部分。Java 的泛型是类型擦除:List<String> 和 List<Integer> 在运行时是同一个 List,编译器插入强制转换,所以 new T()、new T[]、基本类型做类型参数统统做不到。

C++ 模板是完全不同的机制:实例化。std::vector<int> 和 std::vector<std::string> 是编译器生成的两份完全独立的代码,各有一份机器指令。这带来三个后果:

  1. 零运行时开销:没有装箱拆箱,没有类型转换,vector<int> 里就是紧密排列的 int。
  2. 类型参数可以是基本类型,甚至是非类型的值(见后文)。
  3. 代码膨胀:每个实例化都会产生一份代码,编译也慢一些。

Python 走的是第三条路——鸭子类型:根本不做类型检查,运行时有 __len__ 就能 len()。C++ 模板介于两者之间:编译期检查,但不要求类型之间有任何继承关系,只要"能用这些操作符"就行,这在精神上最接近 Python 的鸭子类型,只是把检查提前到了编译期。

#函数模板

语法是 template <typename T> 加在函数前面。typename 和 class 在这里完全等价,写 typename 更贴切(因为它可以是 int 而非类)。

绝大多数情况下编译器能自动推导 T,只有在"无法推导"或"想指定不同类型"时才显式写 func<int>(args)。

C++
#include <iostream>
#include <string>
#include <vector>

// 1) 最简单的函数模板:自动推导 T
template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;
}

// 2) 多个类型参数,返回类型也可以独立
template <typename T, typename U>
auto pair_sum(T a, U b) {
    return a + b;                 // 返回类型由 decltype 推导(C++14)
}

// 3) 显式指定类型参数:当推导有歧义或需要强制转换时
template <typename T>
T create_default() {
    return T{};                   // 值初始化,int 是 0,指针是 nullptr
}

// 4) 模板参数可以是容器,配合 STL 使用
template <typename Container>
void print_all(const Container& c) {
    for (const auto& item : c) {
        std::cout << item << " ";
    }
    std::cout << "\n";
}

// 5) 模板 + 迭代器:最通用的形式,甚至能作用于 C 数组
template <typename Iter>
void print_range(Iter first, Iter last) {
    while (first != last) {
        std::cout << *first << " ";
        ++first;
    }
    std::cout << "\n";
}

int main() {
    // 自动推导:所有实例化在编译期生成
    std::cout << maximum(3, 5) << "\n";                  // int 版本
    std::cout << maximum(3.14, 2.71) << "\n";            // double 版本
    std::cout << maximum(std::string("abc"), std::string("abd")) << "\n";

    // maximum(3, 3.14) 会推导失败:int 和 double 冲突
    std::cout << maximum<double>(3, 3.14) << "\n";       // 显式指定解决

    std::cout << pair_sum(1, 2.5) << "\n";               // T=int, U=double

    int zero = create_default<int>();
    std::cout << "默认 int = " << zero << "\n";

    std::vector<int> v{1, 2, 3};
    print_all(v);

    int arr[]{4, 5, 6};
    print_range(arr, arr + 3);                           // C 数组也能用

    // print_all(42) 会编译失败,因为 int 不支持范围 for ——
    // 这就是"编译期鸭子类型":不检查类型名,只检查操作是否合法
    return 0;
}

注意最后一点:print_all(42) 的错误信息是一大串模板嵌套(新手常被吓到)。C++20 的 concepts 就是为了让这个报错变得可读,见本章最后一节。

#类模板

类模板让你定义"一族类"。std::vector<T>、std::unique_ptr<T> 都是类模板。

关键细节:类模板的成员函数定义必须和声明放在同一个文件里(通常是头文件)。这是因为编译器在实例化时需要看到完整定义——不像普通类可以分离 .h/.cpp。这也是为什么 STL 和 Boost 大量使用头文件。

C++
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

// 一个简易栈:类模板
template <typename T>
class Stack {
public:
    void push(const T& value) {
        data_.push_back(value);
    }

    // 类内定义时,返回类型里的 Stack 可以省略 <T>(注入类名)
    T pop() {
        if (data_.empty()) {
            throw std::out_of_range("栈为空");
        }
        T value = data_.back();
        data_.pop_back();
        return value;
    }

    const T& top() const {
        if (data_.empty()) {
            throw std::out_of_range("栈为空");
        }
        return data_.back();
    }

    bool empty() const { return data_.empty(); }
    std::size_t size() const { return data_.size(); }

private:
    std::vector<T> data_;         // 用 vector 做底层存储,复用它的内存管理
};

// 类外定义成员函数时,必须写完整的模板头
template <typename T>
void clear_stack(Stack<T>& s) {
    while (!s.empty()) {
        s.pop();
    }
}

int main() {
    Stack<int>         ints;
    Stack<std::string> strings;

    ints.push(1);
    ints.push(2);
    std::cout << "栈顶 = " << ints.top() << ",大小 = " << ints.size() << "\n";

    strings.push("hello");
    strings.push("world");
    std::cout << "栈顶 = " << strings.top() << "\n";

    // 类模板的成员函数只有被调用时才会实例化:
    // 下面这行不会触发 Stack<int>::pop 的实例化检查
    Stack<std::vector<int>> unused;

    clear_stack(ints);
    std::cout << "清空后是否为空: " << std::boolalpha << ints.empty() << "\n";
    return 0;
}

"成员函数用到才实例化"是一条重要规则:它意味着模板类里可以包含对某些类型不合法的操作,只要你不调用它就没事。这也是为什么 std::vector<不可拷贝类型> 可以编译,只要你不去拷贝它。

#typename 关键字与非类型模板参数

typename 有两种完全不同的用法,容易混淆:

  1. 声明类型参数:template <typename T>(等价于 class T)。
  2. 消歧义:typename T::value_type——告诉编译器"这个嵌套名字是个类型,不是静态成员"。因为编译模板时 T 还未知,编译器无法判断 T::value_type 是类型还是变量,必须你显式说明。

非类型模板参数(NTTP)是 C++ 相对 Java/C# 的独有能力:模板参数可以是值而不只是类型,比如整数、指针、引用。最典型的应用是 std::array<T, N>——数组长度在编译期确定,零运行时开销。C++17 起还支持 auto 类型的非类型模板参数。

C++
#include <array>
#include <iostream>
#include <string>
#include <vector>

// 1) typename 的消歧义用法:告诉编译器 iterator 是个类型
template <typename Container>
typename Container::value_type sum_of(const Container& c) {
    typename Container::value_type total{};   // 值初始化,适配 int/double/string
    for (const auto& item : c) {
        total = total + item;
    }
    return total;
}

// 2) 非类型模板参数:N 是一个编译期整数
template <typename T, std::size_t N>
class FixedArray {
public:
    constexpr std::size_t size() const { return N; }

    T& operator[](std::size_t i) {
        return data_[i];                 // 不做边界检查,越界即未定义行为
    }

    const T& operator[](std::size_t i) const { return data_[i]; }

    // 编译期计算:constexpr 函数可以用在 static_assert 里
    constexpr std::size_t byte_size() const { return N * sizeof(T); }

private:
    T data_[N]{};                        // 真正的栈上数组,无动态分配
};

// 3) 非类型参数还能做编译期计算:阶乘
template <unsigned N>
struct Factorial {
    static constexpr unsigned value = N * Factorial<N - 1>::value;
};

// 模板特化作为递归终止条件
template <>
struct Factorial<0> {
    static constexpr unsigned value = 1;
};

// 4) C++17:非类型参数用 auto,类型自动推导(C++20 才放宽到浮点/类类型)
template <auto Value>
void show_value() {
    std::cout << "值 = " << Value << "\n";
}

int main() {
    std::vector<int>    v{1, 2, 3, 4};
    std::vector<double> d{1.5, 2.5};
    std::cout << "int 容器求和 = " << sum_of(v) << "\n";
    std::cout << "double 容器求和 = " << sum_of(d) << "\n";

    // 非类型参数:长度是类型的一部分,FixedArray<int, 3> 和 <int, 4> 是不同类型
    FixedArray<int, 5> arr;
    arr[0] = 10;
    std::cout << "大小 " << arr.size() << ",字节数 " << arr.byte_size() << "\n";

    // std::array 就是标准库里的同款实现
    std::array<std::string, 3> names{"Qt", "C++", "STL"};
    std::cout << "names[0] = " << names[0] << "\n";

    // 编译期阶乘:值在编译时就已算好
    static_assert(Factorial<5>::value == 120, "算错了");
    std::cout << "10! = " << Factorial<10>::value << "\n";

    show_value<42>();
    show_value<'A'>();

    // 长度不匹配会在编译期报错,这是编译期数组的好处
    // FixedArray<int, 5> wrong = arr;   // 不同类型,无法赋值
    return 0;
}

#模板特化与偏特化

全特化(full specialization)为某个具体类型提供完全不同的实现,语法是 template <>。典型用途:对 const char* 做特殊处理、对 bool 优化存储。

偏特化(partial specialization)只对类模板有效(函数模板不支持偏特化,只能用重载代替),用于"部分参数固定"的场景,比如 Wrapper<T*> 匹配所有指针类型。

C++
#include <cstring>
#include <iostream>
#include <string>
#include <type_traits>
#include <vector>

// 主模板
template <typename T>
struct TypeName {
    static std::string get() { return "未知类型"; }
};

// 全特化:为具体类型提供专门实现
template <>
struct TypeName<int> {
    static std::string get() { return "int"; }
};

template <>
struct TypeName<double> {
    static std::string get() { return "double"; }
};

template <>
struct TypeName<std::string> {
    static std::string get() { return "std::string"; }
};

// 偏特化:匹配"任意类型的指针"
template <typename T>
struct TypeName<T*> {
    static std::string get() { return TypeName<T>::get() + " 的指针"; }
};

// 偏特化:匹配 vector<T>
template <typename T>
struct TypeName<std::vector<T>> {
    static std::string get() { return "vector<" + TypeName<T>::get() + ">"; }
};

// 函数模板没有偏特化,用重载 + 标签分发代替
// 这里用 std::is_integral 配合编译期 if(C++17)实现"条件分支"
template <typename T>
std::string describe(T value) {
    if constexpr (std::is_integral_v<T>) {
        return "整数类型,值 = " + std::to_string(value);
    } else if constexpr (std::is_floating_point_v<T>) {
        return "浮点类型,值 = " + std::to_string(value);
    } else {
        return "其他类型";
    }
}

int main() {
    std::cout << TypeName<int>::get() << "\n";                 // int
    std::cout << TypeName<double>::get() << "\n";              // double
    std::cout << TypeName<std::string>::get() << "\n";         // std::string
    std::cout << TypeName<char*>::get() << "\n";               // char 的指针
    std::cout << TypeName<std::vector<int>>::get() << "\n";    // vector<int>
    std::cout << TypeName<float>::get() << "\n";               // 未知类型(走主模板)

    std::cout << describe(42) << "\n";
    std::cout << describe(3.14) << "\n";
    std::cout << describe(std::string("abc")) << "\n";

    // if constexpr 是 C++17 的编译期分支:
    // 不满足的分支根本不会被实例化,因此可以对不同类型写不兼容的代码
    return 0;
}

if constexpr 是 C++17 的利器:它和普通 if 的区别在于,被丢弃的分支不会实例化,所以里面可以写对该类型非法的表达式。这大大简化了模板元编程,取代了 C++11 时代大量 SFINAE 技巧。

#auto 返回类型与 decltype

C++14 起,函数返回类型可以写 auto,让编译器从 return 语句推导。这在模板里几乎是必需的——你往往写不出返回类型的名字。

补两个细节:decltype(expr) 求表达式的精确类型(保留引用和 const);decltype(auto)(C++14)则用 decltype 的规则推导,能保留引用。写泛型转发函数时,返回引用必须靠 decltype(auto),否则 auto 会剥掉引用产生副本。

C++20 还允许在函数参数里写 auto,等价于一个匿名模板参数(简写函数模板)。

C++
#include <iostream>
#include <string>
#include <vector>

// 1) auto 返回类型:编译器从 return 推导
template <typename T, typename U>
auto add(T a, U b) {
    return a + b;                 // int + double → double
}

// 2) 尾置返回类型(trailing return type):C++11 写法,复杂表达式时仍需它
template <typename T, typename U>
auto multiply(T a, U b) -> decltype(a * b) {
    return a * b;
}

// 3) auto 会剥掉引用:这个版本返回的是副本
template <typename Container>
auto bad_front(Container& c) {
    return c.front();             // 返回 T(副本),修改它不影响容器
}

// 4) decltype(auto) 保留引用:返回容器内元素的真实引用
template <typename Container>
decltype(auto) good_front(Container& c) {
    return c.front();             // 返回 T&,可以修改
}

// 5) 转发引用 + decltype(auto):完美转发返回值的经典组合
template <typename Container>
decltype(auto) at_index(Container&& c, std::size_t i) {
    return c[i];
}

int main() {
    std::cout << add(1, 2.5) << "\n";          // 3.5
    std::cout << multiply(3, 4.5) << "\n";     // 13.5

    std::vector<int> v{1, 2, 3};

    // auto 版本:拿到副本
    auto a = bad_front(v);
    a = 99;
    std::cout << "副本改了,容器首元素仍是 " << v.front() << "\n";

    // decltype(auto) 版本:拿到引用
    decltype(auto) b = good_front(v);
    b = 99;
    std::cout << "引用改了,容器首元素变成 " << v.front() << "\n";

    std::cout << at_index(v, 1) << "\n";

    // 6) decltype 求表达式类型,常用于声明同类型变量
    decltype(v.size()) n = v.size();           // std::size_t
    std::cout << "元素个数 = " << n << "\n";
    return 0;
}

#Concepts 入门(C++20)

模板错误信息冗长是 C++ 长期被诟病的问题——写错一个类型,编译器会吐出几十行内部实现细节。C++20 的 concepts 解决了两件事:让约束写进签名,让错误说人话。

概念(concept)本质上是"编译期的谓词",用来约束模板参数必须满足什么条件。语法上可以用 requires 子句,也可以直接把 concept 名写在 template <...> 里替代 typename。

C++
// 注意:本段需要 C++20,编译时加 -std=c++20
#include <concepts>
#include <iostream>
#include <string>
#include <vector>

// 1) 自定义 concept:要求类型支持 << 输出到流
template <typename T>
concept Printable = requires(T value, std::ostream& os) {
    { os << value } -> std::convertible_to<std::ostream&>;
};

// 2) 用 concept 约束函数模板,替代 typename
template <Printable T>
void print_one(const T& value) {
    std::cout << value << "\n";
}

// 3) requires 子句的等价写法,可组合多个约束
template <typename T>
    requires Printable<T> && std::copy_constructible<T>
void print_twice(const T& value) {
    std::cout << value << " " << value << "\n";
}

// 4) 标准库预置 concept:integral / floating_point / 等
template <std::integral T>
T gcd(T a, T b) {
    while (b != 0) {
        T t = b;
        b = a % b;
        a = t;
    }
    return a;
}

// 5) auto 参数 + concept(C++20 简写函数模板)
void print_number(std::integral auto value) {
    std::cout << "数字: " << value << "\n";
}

int main() {
    print_one(42);
    print_one(std::string("hello"));
    print_twice(3.14);

    std::cout << "gcd(48, 18) = " << gcd(48, 18) << "\n";
    print_number(100);

    // 下面这行会给出清晰的错误:"constraints not satisfied",
    // 而不是几十行模板内部实现 —— 这就是 concepts 最大的实用价值
    // print_one(std::vector<int>{1, 2, 3});
    return 0;
}

Qt 6 本身仍以 C++17 为主,但了解 concepts 能帮你读懂现代 C++ 代码和编译错误,也让你在需要时能写出更友好的接口。本教程后续章节默认 C++17,凡涉及 concepts 都会像这里一样单独标注。

#小结

  1. C++ 模板是编译期实例化(每个类型生成独立代码),与 Java 的类型擦除、Python 的运行时鸭子类型都不同:零开销,但会增大二进制体积。
  2. 函数模板语法 template <typename T>,多数情况自动推导;推导冲突时用 func<T>(...) 显式指定。
  3. 类模板的成员定义必须放在头文件;成员函数只有被调用时才实例化,所以对某些类型不合法的操作只要不调用就不报错。
  4. typename 既声明类型参数,也用于消歧义嵌套类型名(typename T::value_type);非类型模板参数可以是编译期值,std::array<T, N> 就是典型。
  5. 全特化 template <> 为具体类型定制;偏特化只对类模板有效,函数模板用重载 + if constexpr(C++17)代替。
  6. auto 返回类型会剥掉引用,需要保留引用时用 decltype(auto);C++20 的 concepts 把约束写进签名,把冗长的模板错误变成可读的诊断。

#练习

  1. 写一个函数模板 template <typename T> void swap_values(T& a, T& b),分别用 int、double、std::string 调用,用 typeid 或调试器确认生成了三份不同的代码。
  2. 实现 template <typename T, std::size_t N> class CircularBuffer,支持 push、pop、size,写满时覆盖最旧的数据。用 std::array<T, N> 做底层存储。
  3. 给 TypeName 增加 long、bool、std::vector<std::vector<int>> 的特化,验证嵌套偏特化能正确递归展开。
  4. 用 if constexpr 写一个 template <typename T> std::string to_display(T value):整数转 "123",浮点保留两位小数,字符串原样返回,其他类型返回 "<不支持>"。再改写成 decltype(auto) 返回版本,对比修改返回值时是否影响原容器。最后(C++20)定义 concept Hashable = requires(T a) { { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>; };,写一个只接受 Hashable 类型的函数,观察错误信息有多友好。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。