c++ 类模板与类成员函数模板（简单）

原创已于 2025-03-11 17:04:49 修改 · 539 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

于 2025-03-11 15:49:50 首次发布

C++ 专栏收录该内容

65 篇文章

订阅专栏

在C++中，类模板（Class Template）是一种强大的工具，允许编写通用的类，可以处理多种类型的数据。类模板的使用场景非常广泛，例如实现容器类（如std::vector、std::list等）。以下是对类模板及其相关概念的简单说明和示例。

1. 类模板的定义

类模板允许我们定义一个通用的类，其中的某些成员类型或成员函数的参数类型可以是模板参数。

语法：

template <typename T>
class ClassName {
    // 类成员定义
};

示例：

#include <iostream>

template <typename T>
class Box {
private:
    T value;
public:
    Box(T v) : value(v) {}
    void display() const {
        std::cout << "Value: " << value << std::endl;
    }
};

2. 类模板的显式实例化

显式实例化是指在代码中明确指定类模板针对某种类型的实例化。它的语法如下：

template class ClassName<Type>;  // 显式实例化定义

示例：

#include <iostream>

template <typename T>
class Box {
private:
    T value;
public:
    Box(T v) : value(v) {}
    void display() const {
        std::cout << "Value: " << value << std::endl;
    }
};

// 显式实例化定义
template class Box<int>;    // 针对 int 类型的显式实例化
template class Box<double>; // 针对 double 类型的显式实例化

int main() {
    Box<int> intBox(42);
    intBox.display();  // 输出: Value: 42

    Box<double> doubleBox(3.14);
    doubleBox.display();  // 输出: Value: 3.14
    return 0;
}

3. 类模板的隐式实例化

隐式实例化是指在代码中使用类模板时，编译器自动根据模板参数类型生成对应的类。

示例：

#include <iostream>

template <typename T>
class Box {
private:
    T value;
public:
    Box(T v) : value(v) {}
    void display() const {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    Box<int> intBox(42);       // 隐式实例化 Box<int>
    intBox.display();          // 输出: Value: 42

    Box<double> doubleBox(3.14); // 隐式实例化 Box<double>
    doubleBox.display();        // 输出: Value: 3.14
    return 0;
}

4. 类模板的使用场景

类模板常用于以下场景：

容器类：如std::vector、std::list等。
通用算法类：如排序、查找等算法的封装。
智能指针：如std::shared_ptr、std::unique_ptr等。

5. 类成员函数模板

类成员函数模板是指类中的成员函数本身是模板函数。它可以是普通类的成员函数模板，也可以是类模板的成员函数模板。

5.1 普通类的成员函数模板

语法：

class ClassName {
public:
    template <typename T>
    void memberFunction(T arg);
};

示例：

#include <iostream>

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

int main() {
    Printer p;
    p.print(42);       // 输出: Value: 42
    p.print(3.14);     // 输出: Value: 3.14
    p.print("Hello");  // 输出: Value: Hello
    return 0;
}

5.2 类模板的成员函数模板

语法：

template <typename U>
class ClassName {
public:
    template <typename T>
    void memberFunction(T arg);
};

示例：

#include <iostream>

template <typename U>
class Box {
private:
    U value;
public:
    Box(U v) : value(v) {}
    template <typename T>
    void display(T prefix) const {
        std::cout << prefix << " Value: " << value << std::endl;
    }
};

int main() {
    Box<int> intBox(42);
    intBox.display("IntBox:");  // 输出: IntBox: Value: 42

    Box<double> doubleBox(3.14);
    doubleBox.display("DoubleBox:");  // 输出: DoubleBox: Value: 3.14
    return 0;
}

6. 类模板的特化

类模板的特化是指为类模板的某个特定类型提供一个特殊的实现。特化分为完全特化和部分特化。

6.1 完全特化

完全特化是指为类模板的某个特定类型提供一个完全不同的实现。

语法：

template <>
class ClassName<Type> {
    // 特化实现
};

示例：

#include <iostream>

template <typename T>
class Box {
public:
    void display() const {
        std::cout << "Generic Box" << std::endl;
    }
};

// 完全特化
template <>
class Box<int> {
public:
    void display() const {
        std::cout << "Specialized Box for int" << std::endl;
    }
};

int main() {
    Box<double> doubleBox;
    doubleBox.display();  // 输出: Generic Box

    Box<int> intBox;
    intBox.display();  // 输出: Specialized Box for int
    return 0;
}

6.2 部分特化

部分特化是指为类模板的某些特定类型组合提供一个特殊的实现。

语法：

template <typename T>
class ClassName<T, Type> {
    // 部分特化实现
};

示例：

#include <iostream>

template <typename T, typename U>
class Pair {
public:
    void display() const {
        std::cout << "Generic Pair" << std::endl;
    }
};

// 部分特化
template <typename T>
class Pair<T, int> {
public:
    void display() const {
        std::cout << "Partial Specialization for Pair<T, int>" << std::endl;
    }
};

int main() {
    Pair<double, double> p1;
    p1.display();  // 输出: Generic Pair

    Pair<double, int> p2;
    p2.display();  // 输出: Partial Specialization for Pair<T, int>
    return 0;
}