模板参数：类型参数与非类型参数的区别

在C++模板编程中，模板参数是构建泛型代码的核心基础------它决定了模板的灵活性和适配范围。很多新手入门模板时，很容易混淆「类型参数」和「非类型参数」：两者都写在模板的尖括号<>中，语法相似，但作用、用法和限制却天差地别。

今天这篇博客，就用"概念+语法+案例+对比"的方式，把两者的区别讲透，每个知识点都搭配可直接编译的代码，帮你彻底分清、灵活运用这两类模板参数。

一、先明确核心定义：什么是模板参数？

模板参数，简单来说，就是「模板被实例化时，需要传入的"参数"」------类比函数参数：函数参数是运行时传入具体值，模板参数是编译期传入具体"内容"，让编译器根据传入的参数，生成对应版本的代码。

根据传入"内容"的不同，模板参数分为两大类：

类型参数：传入的是「数据类型」（如int、double、std::string、自定义结构体）；
非类型参数：传入的是「常量值」（如10、3.14、nullptr、常量表达式）。

一句话总结：类型参数负责"适配不同类型"，非类型参数负责"适配不同常量值"，两者协同，让模板的泛化能力更全面。

二、类型参数：最常用的模板参数（适配不同类型）

类型参数是我们写模板时最常使用的参数类型，也是模板实现"泛型"的核心------通过传入不同的类型，让一份模板代码适配多种数据类型，避免重复编码。

2.1 语法格式

类型参数的语法非常固定，核心是用「typename」或「class」关键字修饰（两者在定义类型参数时完全等价，可互换使用）：

cpp 复制代码

// 单个类型参数
template <typename T>  // T是类型参数，代表"任意数据类型"
// 或 template <class T>（与上面完全等价）

// 多个类型参数（用逗号分隔）
template <typename T1, typename T2>  // T1、T2都是类型参数

注意：typename是C++11后推荐使用的关键字，更清晰地表明"这是一个类型参数"；class是早期语法，兼容所有编译器，两者无功能区别。

2.2 实用案例（一看就会）

最经典的案例：实现一个通用的交换函数，适配int、double、std::string等所有可赋值类型，这里就用到了类型参数。

cpp 复制代码

#include <iostream>
#include <string>

// 定义模板，T是类型参数（代表任意可交换类型）
template <typename T>
void swapData(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

// 测试：传入不同类型，模板自动实例化对应版本
int main() {
    // 1. 传入int类型，模板实例化 swapData<int>
    int a = 10, b = 20;
    swapData(a, b);
    std::cout << "int交换后：a=" << a << ", b=" << b << std::endl; // 20, 10
    
    // 2. 传入double类型，模板实例化 swapData<double>
    double c = 3.14, d = 6.28;
    swapData(c, d);
    std::cout << "double交换后：c=" << c << ", d=" << d << std::endl; // 6.28, 3.14
    
    // 3. 传入std::string类型，模板实例化 swapData<std::string>
    std::string e = "hello", f = "world";
    swapData(e, f);
    std::cout << "string交换后：e=" << e << ", f=" << f << std::endl; // world, hello
    
    return 0;
}

案例解析：我们只写了一份swapData模板，编译器在编译期，根据传入的不同类型（int、double、string），自动生成3份不同的函数实现------这就是类型参数的核心作用：用一个参数，适配所有合法类型。

2.3 类型参数的关键特点

传入的必须是「完整的数据类型」，不能是变量、常量或表达式；
可搭配模板特化（上一篇博客重点讲过），为特定类型定制实现；
支持默认参数（C++11后）：比如template ，当不传入类型时，默认使用int；
无数量限制（理论上），可定义多个类型参数，适配更复杂的泛型场景。

三、非类型参数：用常量值定制模板（适配不同常量）

非类型参数是容易被忽略，但非常实用的模板参数------它允许我们在模板实例化时，传入一个「常量值」，让模板根据这个常量值，生成不同的代码版本。

注意：非类型参数传入的是「编译期常量」，不是运行时变量------这是它和类型参数最核心的区别之一，也是新手最容易踩坑的点。

3.1 语法格式

非类型参数不需要typename/class修饰，直接指定「参数类型」和「参数名」，语法和定义普通变量相似，但有严格限制：

cpp 复制代码

// 单个非类型参数（类型必须是"可作为非类型参数"的类型）
template <int N>  // N是非类型参数，代表"int类型的编译期常量"

// 多个非类型参数（可搭配类型参数）
template <typename T, double D>  // T是类型参数，D是非类型参数

重点限制：非类型参数的「类型」只能是以下几种（C++标准规定）：

算术类型（int、char、long、double、bool等）；
指针类型（函数指针、对象指针、 nullptr）；
引用类型（对象引用、函数引用）；
枚举类型（C++11后）。

常见错误：用std::string、自定义结构体作为非类型参数的类型，会直接编译报错------因为这些类型无法作为编译期常量。

3.2 实用案例（直击应用场景）

最经典的场景：实现一个固定大小的通用数组（编译期确定数组大小），这里就用到了非类型参数------数组大小必须是编译期常量，而非类型参数正好能满足这个需求。

cpp 复制代码

#include <iostream>

// 模板：T是类型参数（数组元素类型），N是非类型参数（数组大小，编译期常量）
template <typename T, int N>
class FixedArray {
public:
    // 构造函数：初始化数组元素为默认值
    FixedArray() : arr{} {}
    
    // 打印数组所有元素
    void printArray() {
        for (int i = 0; i < N; ++i) {
            std::cout << arr[i] << " ";
        }
        std::cout << std::endl;
    }
    
    // 赋值操作：给指定下标赋值
    void setValue(int index, const T& value) {
        if (index < 0 || index >= N) {
            std::cout << "下标越界！" << std::endl;
            return;
        }
        arr[index] = value;
    }

private:
    T arr[N];  // 数组大小由非类型参数N决定（编译期确定）
};

// 测试：传入不同的类型和常量值，实例化不同版本的数组
int main() {
    // 1. 实例化：int类型，数组大小为5（N=5）
    FixedArray<int, 5> arr1;
    arr1.setValue(0, 10);
    arr1.setValue(2, 30);
    std::cout << "int数组（大小5）：";
    arr1.printArray();  // 10 0 30 0 0
    
    // 2. 实例化：double类型，数组大小为3（N=3）
    FixedArray<double, 3> arr2;
    arr2.setValue(0, 3.14);
    arr2.setValue(1, 6.28);
    std::cout << "double数组（大小3）：";
    arr2.printArray();  // 3.14 6.28 0
    
    // 3. 实例化：char类型，数组大小为6（N=6）
    FixedArray<char, 6> arr3;
    arr3.setValue(0, 'h');
    arr3.setValue(1, 'i');
    std::cout << "char数组（大小6）：";
    arr3.printArray();  // h i  （后面为默认空字符）
    
    return 0;
}

案例解析：这里的N是非类型参数，传入的是5、3、6这些编译期常量------编译器会根据传入的N值，生成不同大小的数组类：FixedArray<int,5>（大小5）、FixedArray<double,3>（大小3），每个版本的数组大小都是固定的，编译期确定，效率更高。

3.3 非类型参数的关键特点

传入的必须是「编译期常量」，不能是运行时变量（比如int n=5; FixedArray<int, n> arr; 会报错）；
参数类型有严格限制（只能是算术、指针、引用、枚举类型）；
可搭配类型参数使用，实现"类型+常量"的双重泛化；
支持默认参数：比如template <typename T, int N=10>，默认数组大小为10。

四、核心对比：类型参数 vs 非类型参数（避坑重点）

为了方便大家快速区分和记忆，整理了一份对比表，把两者的核心区别、语法、限制都列清楚，直接收藏备用：

对比维度	类型参数	非类型参数
核心作用	适配不同的数据类型	适配不同的编译期常量值
语法修饰	必须用typename或class修饰	不需要修饰，直接写类型+参数名
传入内容	完整的数据类型（如int、string）	编译期常量（如10、3.14、nullptr）
类型限制	无限制（任意合法数据类型）	仅限算术、指针、引用、枚举类型
实例化依据	根据传入的类型实例化	根据传入的常量值实例化
常见场景	通用函数（swap）、通用类（vector）	固定大小数组、编译期常量配置

五、新手常见坑（必看避坑）

坑1：用运行时变量作为非类型参数

非类型参数必须是编译期常量，运行时变量（值在运行时确定）无法作为非类型参数，否则编译报错：

cpp 复制代码

template <int N>
void func() {}

int main() {
    int n = 5;  // 运行时变量（值可修改）
    func<n>();  // 错误：n不是编译期常量
    func<5>();  // 正确：5是编译期常量
    return 0;
}

坑2：混淆typename和非类型参数的语法

类型参数必须加typename/class，非类型参数不能加，否则编译报错：

cpp 复制代码

// 错误：类型参数漏写typename/class
template <T>  // T是类型参数，必须加typename/class
void swapData(T& a, T& b) {}

// 错误：非类型参数多写typename
template <typename int N>  // N是非类型参数，不能加typename
void func() {}

// 正确写法
template <typename T>
void swapData(T& a, T& b) {}

template <int N>
void func() {}

坑3：用非法类型作为非类型参数

std::string、自定义结构体等类型，不能作为非类型参数的类型：

cpp 复制代码

#include <string>

// 错误：std::string不能作为非类型参数的类型
template <std::string S>
void func() {}

// 正确：用const char*（指针类型）替代
template <const char* S>
void func() {}

const char str[] = "hello";
int main() {
    func<str>();  // 正确
    return 0;
}

六、总结：如何灵活运用两类参数？

其实记住一句话，就能分清并用好两者：

需要适配"不同类型"，就用类型参数（typename/class修饰）；需要适配"不同常量值"，就用非类型参数（直接写类型+参数名）。

两者不是对立关系，而是协同关系------在实际开发中，很多复杂模板会同时使用类型参数和非类型参数，比如STL中的std::array（模板定义：template <typename T, size_t N> class array;）：T是类型参数（数组元素类型），N是非类型参数（数组大小），完美结合了两者的优势。

最后提醒：模板参数的核心是「编译期确定」，无论是类型还是常量值，都要在编译期明确------这是模板高效运行的关键，也是和函数参数（运行时传入）最本质的区别。