什么是泛型编程

原创 已于 2025-07-22 22:38:54 修改 · 758 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #C++

于 2025-07-22 22:12:06 首次发布

什么是泛型编程

泛型编程就是传递变量类型的编程
主要作用1：节省代码
主要作用2：传递参数类型
主要作用3：写底层架构

一 节省代码

// ConsoleApplication9.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;

template<typename T>  // 或 template<class T>
void ShowT(T a) {

    cout << a << endl;
   
}

void Show(int a)
{
    cout << a << endl;
}
void Show(double a)
{
    cout << a << endl;
}

void Show(char a)
{
    cout << a << endl;
}


int main()
{
    int a = 99;
    double b = 9.6666;
    char c = 'a';
    //Show(a);
    //Show(b);
    //Show(c);

    ShowT(a);
    ShowT(b);
    ShowT(c);

}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

传递参数类型（泛型编程又称传递参数编程，可见之重要）

// ConsoleApplication9.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;

template<typename T>  // 或 template<class T>
void ShowT(T a) {

    cout << a << endl;
   
}

void Show(int a)
{
    cout << a << endl;
}
void Show(double a)
{
    cout << a << endl;
}

void Show(char a)
{
    cout << a << endl;
}


int main()
{
    int a = 99;
    double b = 9.6666;
    char c = 'a';
    //Show(a);
    //Show(b);
    //Show(c);

    ShowT(a);
    ShowT(b);
    ShowT(c);
    ShowT<int>(a);
    ShowT<double>(b);
    ShowT<char>(c);

}


// ConsoleApplication9.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;

template<typename T>  // 或 template<class T>
void ShowT(T a) {

    cout << a << endl;
   
}

void Show(int a)
{
    cout << a << endl;
}
void Show(double a)
{
    cout << a << endl;
}

void Show(char a)
{
    cout << a << endl;
}


template<typename T1, typename T2>  // 或 template<class T>
void MyTest(T1 a, T2 b)
{

    std::cout << "Type of T1: " << typeid(T1).name() << std::endl;
    std::cout << "Type of T2: " << typeid(T2).name() << std::endl;


}


int main()
{
    int a = 99;
    double b = 9.6666;
    char c = 'a';
    //Show(a);
    //Show(b);
    //Show(c);

    //ShowT(a);
    //ShowT(b);
    //ShowT(c);
    //ShowT<int>(a);
    //ShowT<double>(b);
    //ShowT<char>(c);

    MyTest<int,double>(1,2.1);

}

在 C++ 中，获取类的类型（即类型信息）可以通过多种方式实现，具体取决于使用场景。以下是常见的方法：

1. 使用 typeid 运算符（RTTI）

typeid 是 C++ 运行时类型识别（RTTI）机制的一部分，返回一个 std::type_info 对象，可用于获取类型名称或比较类型。

#include <iostream>
#include <typeinfo>

class MyClass {};

int main() {
    MyClass obj;
    const std::type_info& ti = typeid(obj);
    
    std::cout << "Type name: " << ti.name() << std::endl; // 输出类型名称（可能是编译器修饰的）
    std::cout << "Is MyClass? " << (ti == typeid(MyClass)) << std::endl; // 比较类型
    
    return 0;
}

注意事项：

  • ti.name() 返回的名称可能是编译器修饰的（如 4MyClass），不同编译器表现不同。
  • 需要启用 RTTI（默认开启，可通过编译器选项 -fno-rtti 禁用）。
  • 适用于多态类型（有虚函数的类）时能获取动态类型，否则获取静态类型。

2. 使用 decltype（编译时类型推导）

decltype 用于推导表达式的类型，常用于模板元编程或返回类型推导。

#include <iostream>

class MyClass {};

int main() {
    MyClass obj;
    decltype(obj) obj2; // obj2 的类型是 MyClass
    
    std::cout << "Type of obj2 is MyClass" << std::endl;
    return 0;
}

典型用途：

  • 在模板中推导参数类型：
    template<typename T>
auto get_value(T t) -> decltype(t.get_value()) {
    return t.get_value();
}
  • C++14 起用于泛型 lambda：
    auto lambda = [](auto x) { return decltype(x)(0); };

3. 使用 auto 和类型别名

通过 auto 自动推导变量类型，或使用 using/typedef 定义类型别名。

#include <iostream>

class MyClass {};

int main() {
    MyClass obj;
    auto obj2 = obj; // obj2 的类型自动推导为 MyClass
    
    using MyType = MyClass; // 类型别名
    MyType obj3;
    
    std::cout << "obj2 is of type MyClass" << std::endl;
    return 0;
}

4. 模板参数类型提取

在模板中，可以通过 typename 或 class 获取模板参数的类型。

#include <iostream>

template<typename T>
class Wrapper {
public:
    using value_type = T; // 定义内部类型别名
};

int main() {
    Wrapper<int> w;
    Wrapper<int>::value_type x = 42; // x 的类型是 int
    
    std::cout << "x = " << x << std::endl;
    return 0;
}

5. C++17 的 std::void_t 和 SFINAE 类型检测

通过模板技巧在编译时检测类的成员类型或属性。

#include <iostream>
#include <type_traits>

class MyClass {
public:
    using value_type = int;
};

// 检测类是否有 value_type 成员
template<typename T, typename = void>
struct has_value_type : std::false_type {};

template<typename T>
struct has_value_type<T, std::void_t<typename T::value_type>> : std::true_type {};

int main() {
    std::cout << "MyClass has value_type? " 
              << has_value_type<MyClass>::value << std::endl; // 输出 1 (true)
    return 0;
}

6. 获取类的 this 类型（C++11 起）

使用 decltype 或 std::declval 获取类的 this 类型。

#include <iostream>
#include <utility>

class MyClass {
public:
    auto get_this_type() -> decltype(*this) { 
        return *this; 
    }
    
    // C++14 起可简化为：
    // auto get_this_type() { return *this; }
};

int main() {
    MyClass obj;
    auto obj2 = obj.get_this_type(); // obj2 的类型是 MyClass
    return 0;
}

7. C++20 的 Concepts（类型约束）

通过 Concepts 显式约束模板参数的类型。

#include <iostream>
#include <concepts>

template<typename T>
concept IsMyClass = requires(T t) {
    { t } -> std::convertible_to<T>; // 简单约束
};

class MyClass {};

void print_type(IsMyClass auto obj) {
    std::cout << "obj is of type MyClass or compatible" << std::endl;
}

int main() {
    MyClass obj;
    print_type(obj); // 匹配成功
    return 0;
}

总结

方法适用场景特点
typeid运行时类型识别需要 RTTI，名称可能被修饰
decltype编译时类型推导适用于表达式和变量
auto自动类型推导简化代码，但隐藏具体类型
模板参数泛型编程通过 typename 提取类型
SFINAE/void_t编译时类型检测复杂但强大
C++20 Concepts类型约束语义清晰，替代部分 SFINAE

根据需求选择合适的方法：

  • 需要运行时信息 → typeid。
  • 需要编译时类型推导 → decltype 或模板参数。
  • 需要类型约束 → C++20 Concepts。
  • 需要检测类型特征 → SFINAE 或 void_t。

C++泛型编程教程：从模板到STL的深度实践

一、泛型编程的核心思想

泛型编程（Generic Programming）通过参数化类型实现代码复用，其核心在于编写与具体数据类型无关的通用算法。例如，一个排序算法无需为int、double或自定义类型重复实现，只需通过模板机制生成不同版本的代码。这种范式在C++中通过**模板（Templates）**实现，其优势体现在：

  • 代码复用性：STL中的vector<T>可存储任意类型，避免为每种类型重复实现动态数组。
  • 类型安全：编译期类型检查消除运行时类型错误（如Java泛型的类型擦除问题）。
  • 性能优化：生成的代码与原生类型操作效率相当，如vector<int>的访问速度接近数组。

二、函数模板：通用算法的基石

1. 基本语法与实例化

template<typename T>  // 或 template<class T>
T max(T a, T b) {
    return a > b ? a : b;
}

int main() {
    cout << max(3, 5);          // 隐式实例化：T=int
    cout << max<double>(3.14, 2.71); // 显式实例化：T=double
}
  • 隐式推导：编译器根据参数类型自动确定T。
  • 显式指定：通过<类型>明确指定模板参数，解决多参数类型不一致问题。

2. 模板特化：定制化实现

为特定类型提供优化逻辑：

// 全特化：针对char*类型
template<>
const char* max<const char*>(const char* a, const char* b) {
    return strcmp(a, b) > 0 ? a : b;
}

// 偏特化（C++不支持直接偏特化函数模板，需通过类模板间接实现）

3. 非类型模板参数

传递编译期常量：

template<typename T, int N>
class FixedArray {
    T data[N];
public:
    T& operator[](int i) { return data[i]; }
};

FixedArray<int, 10> arr; // 创建固定大小为10的整型数组

三、类模板：通用数据结构的实现

1. 基本类模板

template<typename T>
class Stack {
    T* data;
    int top;
public:
    Stack(int size) : data(new T[size]), top(0) {}
    void push(T val) { data[top++] = val; }
    T pop() { return data[--top]; }
};

Stack<string> strStack; // 存储字符串的栈

2. 模板参数默认值

template<typename T = int, int N = 100>
class Buffer {
    T data[N];
};

Buffer<> buf1; // T=int, N=100
Buffer<double, 200> buf2; // T=double, N=200

3. 类模板的特化

为指针类型优化内存管理：

template<typename T>
class SmartPtr {
    T* ptr;
public:
    SmartPtr(T* p) : ptr(p) {}
    ~SmartPtr() { delete ptr; }
};

// 特化版本：处理字符指针（不调用delete）
template<>
class SmartPtr<char*> {
    char* ptr;
public:
    SmartPtr(char* p) : ptr(p) {}
    ~SmartPtr() { /* 不释放内存 */ }
};

四、可变参数模板：C++11的扩展

1. 参数包展开

// 递归展开
void print() {} // 终止函数

template<typename T, typename... Args>
void print(T first, Args... args) {
    cout << first << " ";
    print(args...); // 递归调用
}

print(1, 3.14, "hello"); // 输出：1 3.14 hello

2. 折叠表达式（C++17）

简化参数包运算：

template<typename... Args>
auto sum(Args... args) {
    return (args + ...); // 展开为 (a1 + a2 + ... + an)
}

cout << sum(1, 2, 3); // 输出6

五、STL：泛型编程的典范

1. 容器（Containers）

  • 顺序容器：
    vector<int> vec = {1, 2, 3}; // 动态数组
deque<double> dq;            // 双端队列
list<string> lst;            // 双向链表
  • 关联容器：
    set<int> s;                  // 红黑树实现的有序集合
map<string, int> m;          // 键值对映射
unordered_map<int, string> um; // 哈希表实现的无序映射

2. 算法（Algorithms）

vector<int> v = {3, 1, 4, 1, 5};
sort(v.begin(), v.end());     // 排序
find(v.begin(), v.end(), 4);  // 查找
for_each(v.begin(), v.end(), [](int x) { cout << x << " "; });

3. 迭代器（Iterators）

vector<int>::iterator it = v.begin(); // 随机访问迭代器
list<string>::iterator lit = lst.begin(); // 双向迭代器

六、高级技巧与注意事项

1. 显式实例化与分离编译

  • 显式实例化：
    template class Stack<float>; // 强制生成Stack<float>的代码
  • 分离编译：将模板声明放在.h文件，定义放在.tpp或.h中（需包含实现）。

2. 模板元编程（TMP）

编译期计算示例：

template<int N>
struct Factorial {
    static const int value = N * Factorial<N-1>::value;
};

template<>
struct Factorial<0> {
    static const int value = 1;
};

cout << Factorial<5>::value; // 输出120

3. 性能权衡

  • 代码膨胀：每个模板实例化生成独立代码，需权衡复用性与二进制体积。
  • 编译时间：复杂模板（如元编程）显著增加编译时间，可通过extern template减少重复实例化。

七、实战案例：通用矩阵运算库

template<typename T>
class Matrix {
    vector<vector<T>> data;
public:
    Matrix(int rows, int cols) : data(rows, vector<T>(cols)) {}
    
    Matrix operator+(const Matrix& other) {
        Matrix result(data.size(), data[0].size());
        for (int i = 0; i < data.size(); ++i) {
            for (int j = 0; j < data[0].size(); ++j) {
                result.data[i][j] = data[i][j] + other.data[i][j];
            }
        }
        return result;
    }
    
    // 可添加运算符*、转置、行列式计算等通用方法
};

Matrix<double> m1(3, 3), m2(3, 3);
auto m3 = m1 + m2; // 支持double类型矩阵运算

八、总结

C++泛型编程通过模板机制实现了算法与数据类型的解耦，其核心在于：

  1. 模板语法：函数模板、类模板、可变参数模板。
  2. 特化与偏特化：为特定类型提供优化实现。
  3. STL应用：容器、算法、迭代器的协同工作。
  4. 高级特性：模板元编程、编译期计算、性能优化技巧。

掌握泛型编程需结合实践，建议从STL源码分析入手，逐步深入模板元编程等高级主题。

什么是泛型编程和模板技术？C语言中如何实现泛型编程？
weixin_68551689的博客
11-20 639
泛型编程的核心思想是将算法和数据结构与特定数据类型分离，使其能够适用于多种数据类型而不需要修改代码。泛型代码具有通用性，可以在不同的场景和需求中重复使用，从而提高了代码的灵活性和可维护性。代码重用：泛型编程使得可以编写与数据类型无关的代码，从而增加了代码的重用性。相同的算法和数据结构可以用于不同类型的数据，而无需为每种类型编写新的代码。抽象程度提高：通过使用泛型编程，程序员可以更抽象地思考问题，专注于算法和逻辑，而不必过多关注具体的数据类型。这有助于提高代码的可读性和可维护性。类型安全。
泛型编程与模板
修行的凡人的博客
11-14 3973
基于著名书籍和自我学习得出的泛型编程与模板知识
什么是范型编程
sky4fly的专栏
06-20 785
        泛型编程让你编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。泛型编程的代表作品STL是一种高效、泛型、可交互操作的 软件组件。所谓泛型(Genericity)，是指具有在多种数据类型上皆可操作的含意，与模板有些相似。STL巨大，而且可以扩充，它包含很多计算机基 本算法和数据结构，而且将算法与数据结构完全分离，其中算法是泛型的，不与任何特定数据结构或对象
范型编程（一）
jurisp的专栏
09-26 195
初次学习，概念比较多，整理一下： 1 通配符类型 wildcard tyoe： 2 范型类 generic class：具有一个或多个类型变量的类。 3 范型方法：  &lt;T&gt; 叫做类型变量，放在修饰符的后面，返回类型的前面。 pubic static &lt;T&gt; T getMiddle(T[] a) { //... }  4 类型变量的限定。 T叫做...
c语言讨论--范型编程
SapphireStart
06-16 1196
------ 小BOBI2010.01.03 2010年新年快乐 BOBI是个乖孩子~ 每次你认真跟他讲话的时候， 仿佛都能听懂……~ 新年来了！ 希望内心的小小心愿可以实现…… BOBI是个乖孩子~ 每次你认真跟他讲话的时候， 仿佛都能听懂……~ 新年来了！ 希望内心的小小心愿可以实现…… BOBI是个乖孩子~ 每次你认真跟他讲话的时候， 仿佛都能听懂……~
泛型编程
黎先生的博客
06-12 545
1. 了解什么是泛型 编程范式的英语是 programming paradigm，范即模范之意，范式即模式、方法，是一类典型的编程风格，是指从事软件工程的一类典型的风格（可以对照“方法学”一词）。 编程语言发展到今天，出现了好多不同的代码编写方式，但不同的方式解决的都是同一个问题，那就是如何写出更为通用、更具可重用性的代码或模块。 C 语言的泛型 一个泛型的示例 - swap 函数 好了...
C++程序设计与实践：11-模板和泛型编程.ppt
06-12
C++程序设计与实践：模板和泛型编程 C++ 程序设计与实践中，模板和泛型编程是非常重要的概念。模板是 C++ 的泛型机制，用来实现泛型编程。泛型编程是指不依赖于任何具体类型来编写通用代码，具体类型信息的提供是在...
C++泛型编程
ymhdt的博客
11-02 1025
泛型编程主要使用模板来实现。模板就是允许你编写与类型无关的代码，即对所有传入的数据类型编写通用的实现代码。比如，我想返回传入数据的占内存大小。对这个问题的解决，可以不依赖数据类型，我们都可以通过相同的操作返回结果。函数模板的定义如下代码：注意：每个函数模板都要在其之前使用template<>声明，不可复用。// 指定一个参数类型的函数模板// 指定多个参数类型的函数模板//指定可变参数函数模板模板定义的语法不用多说，但是模板参数有很多知识点需要掌握。类模板的定义形式和函数模板没有太大区别。
C++之泛型编程
最新发布
y020526的博客
01-21 1348
泛型编程是一种通过编写与具体数据类型无关的代码，以实现代码重用的编程范式。在C++中，泛型编程的核心思想是通过模版(template)实现类型参数化，使得函数或类能够适用于多种数据类型。
泛型编程浅析
普拉旺斯
09-24 608
Java泛型的构成泛型变量起到的作用：（给编译器带来类型检查的信息）泛型属于Java的语法糖的一种，提高了Java的健壮性和降低了程序的复杂性泛型的好处： 简单易用 消除强制类型转换 保证类型安全 直接提高了代码的重用率下面就是一个使用泛型的小例子，简单表现了泛型的优点：
泛型编程简介
年少轻狂，幸福时光
08-12 804
    在数据结构中，很大的一个特点就是只专注于数据元素之间的关系及特定结构上的算法，并不关注数据元素的具体类型。鉴于这个特点， 不考虑数据类型的泛型编程就非常适合用于数据结构。     泛型编程是不考虑具体数据类型的编程方式     例如对于交换两个数值的函数Swap，就可以考虑下边的泛型写法 void Swap(T&amp; a, T&amp; b) { T temp; ...
泛型编程的简介
仗劍走天涯
02-07 1574
泛型编程是一种新的编程思想，基于模板技术有效的将算法和数据结构分离。泛型编程是指编写完全一般化并恶意重复使用的算法。就是指具有在多种数据类型上皆可操作，在c++上就是使用模板实现。 例如：我们要实现各个数据类型的最大值。需要写如下的函数重载。 int max(int a, int b) { return (a > b) ? a : b; } float max(float a, f...
泛型编程基础
热门推荐
万里归来少年心
09-03 1万+
1.C++两种抽象方法 （1）面向对象编程 封装（Encapsulation） 继承（Inheritance） 多态（Polymorphism） （2）泛型编程 概念（concepts） 模型化（modeling） 强化（refinement） 2.泛型编程概念 泛型编程(Generic Programming) 指在多种数据类型上皆可操作。和面向对象编程不同，它并不要求额...
C++泛型编程思想方法总结
自由理想的足迹
08-15 1万+
C++用模板来实现泛型编程，模板分为函数模板和类模板。 基本概念：泛型编程范式GP：模板也叫参数类型多态化。 在编译时期确定，相比面向对象的虚函数多态，能够有更高的效率。 泛型编程是从一个抽象层面描述一种类型的算法，不管容器类型是什么，是一种不同于OOP的角度来抽象具体算法。 C++0X目前对GP的支持的趋势来看，确实如此，auto/varadic templates这些特性的加入象征着C
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值