C++模板：函数模板、类模板、模板与继承

xiaoding133 xiaoding133 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 5.1w累计阅读 5.2w+平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄19年
关注
原创 最新推荐文章于 2026-08-27 12:48:29 发布 5.1w 阅读 AI 写同款· GEO 优化 ›
C++类模板 类模板 1.3.1 类模板语法 类模板作用： 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<typename T> 类 解释： template — 声明创建模板 typename — 表面其后面的符号是一种数据类型，可以用class代替 T — 通用的数据类型，名称可以替换，通常为大写字母 示例： #include <string> //类模板 template<class NameType, c 阅读详情

  C++模板：描述    

        C++提供一种模板的机制来减少代码重复。比如：对于同一样函数使用不同的数据类型，int,double,char等。C++模板属于“元编程”的范畴。

C++ 模板函数

                 1.支持不同数据类型的函数重载：

#include <iostream>
using namespace std;

int square (int x)
{
  return x * x;
};

float square (float x)
{
  return x * x;
};

double square (double x)
{
  return x * x;
};

main()
{
   int    i, ii;
   float  x, xx;
   double y, yy;

   i = 2;
   x = 2.2;
   y = 2.2;

   ii = square(i);
   cout << i << ": " << ii << endl;

   xx = square(x);
   cout << x << ": " << xx << endl;

   yy = square(y);
   cout << y << ": " << yy << endl;
}


2.支持所有数据类型的函数模板

#include <iostream>
using namespace std;

template <class T>
inline T square(T x)
{
   T result;
   result = x * x;
   return result;
};



main()
{
   int    i, ii;
   float  x, xx;
   double y, yy;

   i = 2;
   x = 2.2;
   y = 2.2;

   ii = square<int>(i);
   cout << i << ": " << ii << endl;

   xx = square<float>(x);
   cout << x << ": " << xx << endl;

   // Explicit use of template
   yy = square<double>(y);// 显式使用模板
   cout << y << ": " << yy << endl;

   yy = square(y);//隐含的方式使用模板
   cout << y << ": " << yy << endl;
}

注明：模板的关键字可以用class或者typename.

  • template<class T>
  • template<typename T>

两者表达的意思是一样的，但是我更喜欢使用后者。

  • 可以采用两种方式使用模板函数square<int>(value) or square(value).
  • 在模板函数的定义中，T代表数据类型。
  • 模板的声明和定义必须在同一个文件中，如头文件中。
  • C语言的宏定义也可以实现函数模板的功能，#define square(x) (x * x)
    但是宏没有类型检查，函数模板有类型检查。

     

    C++ 模板特例化

  • 下面的例子字符串类型需要特殊处理，采用模板的特例化

  • #include <iostream>
using namespace std;

template <class T>
inline T square(T x)
{
   T result;
   result = x * x;
   return result;
};

// 模板特殊化
template <>
string square<string>(string ss)
{
   return (ss+ss);
};

main()
{
   int i = 2, ii;
   string ww("Aaa");

   ii = square<int>(i);
   cout << i << ": " << ii << endl;

    cout << square<string>(ww) << endl;
}

    注明：模板特例化用于当一个数据类型需要进行不同的处理和实现的情况。



  •  C++ 模板无类型参数

  •  

    #include <iostream>
using namespace std;

template <typename T, int count>
void loopIt(T x)
{
   T val[count];

   for(int ii=0; ii<count; ii++)
   { 
       val[ii] = x++;
       cout <<  val[ii] << endl;
   }
};

main()
{
   float xx = 2.1;

   loopIt<float,3>(xx);
}

     C++ 模板默认类型参数以及无类型参数

    #include <iostream>
using namespace std;

template <typename T=float, int count=3>
T multIt(T x)
{
   for(int ii=0; ii<count; ii++)
   {
       x = x * x;
   }
   return x;
};

main()
{
   float xx = 2.1;

   cout << xx << ": " << multIt<>(xx) << endl;;
}


    注明：multIt<>没有指定参数类型，默认为float;

     C++ 类模板

    类模板定义：template <class T> class MyTemplateClass { ... };

    类模板特例化：template <> class MyTemplateClass <specific-data-type> { ... };

    File: Matrix2x2.hpp

    #ifndef MATRIX_2X2_HPP__
#define MATRIX_2X2_HPP__

using namespace std;

/**
    m(11)  m(12)
    m(21)  m(22)
*/

template <class T>
class Matrix2x2
{
public:
   Matrix2x2(T m11, T m12, T m21, T m22);    //constructor
   Matrix2x2(T m[2][2]);
   Matrix2x2();

   int Add(Matrix2x2 x)
   int Multiply(Matrix2x2 x)
   void Print();
   T m[2][2];
};

template <class T>
Matrix2x2<T>::Matrix2x2(T _m11, T _m12, T _m21, T _m22)
{
   m[0][0] = _m11;
   m[0][1] = _m12;
   m[1][0] = _m21;
   m[1][1] = _m22;
}

template <class T>
Matrix2x2<T>::Matrix2x2(T _m)
{
   m[0][0] = _m[0][0];
   m[0][1] = _m[0][1];
   m[1][0] = _m[1][0];
   m[1][1] = _m[1][1];
}

template <class T>
Matrix2x2<T>::Matrix2x2()
{
   m[0][0] = 0;
   m[0][1] = 0;
   m[1][0] = 0;
   m[1][1] = 0;
}

template <class T>
Matrix2x2<T>::Add(Matrix2x2 _x)
{
    Matrix2x2<T> sum;
    sum.m[0][0] = m[0][0] + _x.m[0][0];
    sum.m[0][1] = m[0][1] + _x.m[0][1];
    sum.m[1][0] = m[1][0] + _x.m[1][0];
    sum.m[1][1] = m[1][1] + _x.m[1][1];
    return sum;
}

template <class T>
Matrix2x2<T>::Multiply(Matrix2x2 _x)
{
    Matrix2x2<T> sum;
    sum.m[0][0] = m[0][0] * _x.m[0][0] + m[0][1] * _x.m[1][0];
    sum.m[0][1] = m[0][0] * _x.m[0][1] + m[0][1] * _x.m[1][1];
    sum.m[1][0] = m[1][0] * _x.m[0][0] + m[1][1] * _x.m[1][0];
    sum.m[1][1] = m[1][0] * _x.m[0][1] + m[1][1] * _x.m[1][1];
    return sum;
}

template <class T>
Matrix2x2<T>::Print()
{
    cout << "|" << m[0][0] << "  " <<  m[0][1] << "|" << endl;
    cout << "|" << m[1][0] << "  " <<  m[1][1] << "|" << endl;
}

#endif


    TestMatrix2x2.cpp

    #include <iostream>

#include "Matrix2x2.hpp"

using namespace std;

int main(int argc, char* argv[])
{
    Matrix2x2<int> X(1,2,3,4);
    Matrix2x2<int> Y(5,6,7,8);

    cout << "X:" << endl;
    X.Print();

    cout << "Y:" << endl;
    Y.Print();

    Matrix2x2<int> A = X.Add(Y);
    cout << "A:" << endl;
    A.Print();

    Matrix2x2<int> B = X.Add(Y);
    cout << "B:" << endl;
    B.Print();
}


     

     C++ 普通类和类模板的静态成员变量

    普通类的静态成员函数：

    #include <iostream>

using namespace std;


class XYZ
{
public:
    void putPri();
    static int ipub;
private:
    static int ipri;
};


void XYZ::putPri()
{
    cout << ipri++ << endl;
}

// 静态成员变量初始化:
int XYZ::ipub = 1;
int XYZ::ipri = 1;

main()
{
    XYZ aaa;
    XYZ bbb;

    aaa.putPri();
    cout << aaa.ipub << endl;
    bbb.putPri();
}

    类模板的静态成员：

    #include <iostream>

using namespace std;

template <class T> 
class XYZ
{
public:
    void putPri();
    static T ipub;
private:
    static T ipri;
};

template <class T> 
void XYZ<T>::putPri()
{
    cout << ipri++ << endl;
}

// 静态成员初始化:
template <class T> T XYZ<T>::ipub = 1;
template <class T> T XYZ<T>::ipri = 1.2;

main()
{
    XYZ<int> aaa;
    XYZ<float> bbb;

    aaa.putPri();
    cout << aaa.ipub << endl;
    bbb.putPri();
}

     C++ 模板的模板参数

    #include <iostream>
using namespace std;

template <template <typename T> typename U>
class Xyz
{
    ....
};

     C++ 类模板和继承

    Color.hpp (无模板的基类)

    #ifndef COLOR_HPP__
#define COLOR_HPP__
#include <string>
enum eColor { none = 0, red, white, blue, yellow, green, black };

class Color
{
public:
    Color(eColor color);
    void setColor(eColor color);
    eColor getColor() { return mColor; };
    std::string getStrColor();

protected:
    eColor mColor;
};

Color::Color(eColor _color)
{
   mColor = _color;
}

void Color::setColor(eColor _color)
{
    mColor = _color;
}

std::string Color::getStrColor()
{
    switch(mColor)
    {
       case red:
           return "red";
       case white:
           return "white";
       case blue:
           return "blue";
       case yellow:
           return "yellow";
       case green:
           return "green";
       case black:
           return "black";
       case none:
       default:
           return "none";
    }
}
#endif


    File: Circle.hpp (模板基类)

    #ifndef CIRCLE_HPP__
#define CIRCLE_HPP__
#include <math.h>
#include <string>

#include "Color.hpp"

template <typename T>
class Circle : public Color
{
public:
    Circle(T centerX, T centerY, T radius, eColor color);
    Circle(T centerX, T centerY, T radius);
    Circle(T radius);

    T area();
    T circumference();
    T getX();
    T getY();
    T getRadius();

protected:
    T x;
    T y;
    T radius;
};

template <typename T>
Circle<T>::Circle(T _x, T _y, T _radius, eColor _color)
: Color(_color)
{
    x = _x;
    y = _y;
    radius = _radius;
}

template <typename T>
Circle<T>::Circle(T _x, T _y, T _radius)
: Color(none)
{
    x = _x;
    y = _y;
    radius = _radius;
}

template <typename T>
Circle<T>::Circle(T _radius)
: Color(none)
{
    x = const_cast<T>(0);
    y = const_cast<T>(0);
    radius = _radius;
}

template <typename T>
T Circle<T>::area()
{
    return M_PI * radius * radius;
}

template <typename T>
T Circle<T>::circumference()
{
    return const_cast<T>(2) * M_PI * radius;
}
#endif


    File: testCircle.cpp

     

    #include <iostream>
#include "Circle.hpp"

using namespace std;

int main(int argc, char* argv[])
{
    Circle<float> circleA(0.0, 0.0, 10.0, white);
    cout << "Area: "  << circleA.area() << endl;
    cout << "Color: " << circleA.getStrColor() << endl;
}


     

     一个模板类继承另外一个模板类：

    File: Sphere.hpp (派生类)

    #ifndef SPHERE_HPP__
#define SPHERE_HPP__

#include "Circle.hpp"

template <typename T>
class Sphere : public Circle<T>
{
public:
    Sphere(T centerZ, T centerX, T centerY, T radius, eColor color);
    Sphere(T radius);
    Sphere();

    T surfaceArea();
    T volume();
    T getZ();

private:
    T z;
};

template <typename T>
Sphere<T>::Sphere(T _x, T _y, T _z, T _radius, eColor _color)
: Circle<T>::Circle (_x, _y, _radius, _color)
{
    this->z = _z;
}

template <typename T>
Sphere<T>::Sphere(T _radius)
: Circle<T>::Circle (_radius)
{
    this->x = const_cast<T>(0);
    this->y = const_cast<T>(0);
    this->z = const_cast<T>(0);
    this->radius = _radius;
}

template <typename T>
Sphere<T>::Sphere()
{
    this->x = const_cast<T>(0);
    this->y = const_cast<T>(0);
    this->z = const_cast<T>(0);
    this->radius = const_cast<T>(1);
}

template <typename T>
T Sphere<T>::surfaceArea()
{
    return const_cast<T>(4) * M_PI * this->radius * this->radius;
}

template <typename T>
T Sphere<T>::volume()
{
    T three = 3;
    T four  = 4;
    return four * M_PI * this->radius * this->radius * this->radius / three;
}
#endif


    注明：用this来显示类的依赖

    File: testSphere.cpp

    #include <iostream>
#include "Sphere.hpp"

using namespace std;

int main(int argc, char* argv[])
{
    Sphere<float> sphereA(0.0, 0.0, 0.0,10.0, blue);
    cout << "Volume: " << sphereA.volume() << endl;
    cout << "Color: "  << sphereA.getStrColor() << endl;
}


     



     

     

收录于
C/C++、STL、泛型编程

当前文章被收录于：

C/C++、STL、泛型编程
65 篇文章 5 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
C++函数模板 函数模板 C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板 C++提供两种模板机制:函数模板和类模板 1.2.1 函数模板语法 函数模板作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<typename T> 函数声明或定义 解释： template — 声明创建模板 typename — 表面其后面的符号是一种数据类型，可以用class代替 T — 通用的数据类型，名称可以替换，通常 阅读详情

相关推荐

(一)DaVinci Developer AutoSAR工具 如何新建SWC、Component、RTE工程，超级详细步骤，赚到

​ 1，创建SWC，第一步需要创建一个App组件类型，首先点击Object Brower菜单，然后左键Application Component Types 选项，然后右键New Application Component Type，组件类型的作用是来后续实例一个Compoent 2、 Properties 选项卡中Nane中输入Type的名字，注意根据规范命名规则已CtAp开头，其他默认就好 ​

weixin_42602687的博客 3574

入门指南：C++ 模板类详解

入门指南：C++ 模板类详解

qq_46017342的博客 6331

Revit Dynamo实战：用Excel数据批量生成桥梁模型（附自适应族技巧）

本文详细介绍了如何利用Revit Dynamo结合Excel数据实现桥梁参数化建模，重点讲解了数据驱动建模、自适应族优化及大型项目性能管理三大核心技巧。通过结构化Excel数据、高级自适应族创建和分块处理策略，显著提升桥梁建模效率与设计变更响应能力。

weixin_42520025的博客 386

C++模板编程：从函数模板到类模板，再到与继承的混合使用

泛型编程是现代软件开发中实现代码复用的核心技术，其核心思想是将数据类型参数化，从而编写与类型无关的通用算法和数据结构。在C++中，这一思想通过模板技术得以实现，包括函数模板和类模板。函数模板让算法摆脱了具体类型的束缚，实现了“一次编写，处处适用”；类模板则是构建泛型数据结构的基石，如STL中的vector和list。模板的编译期实例化机制带来了零运行时开销的性能优势，但也需注意代码膨胀问题。当模板与面向对象的继承机制结合时，既能实现强大的静态多态（如CRTP模式），也需小心处理依赖名称查找等细节。本文深入探

weixin_32667955的博客 243

在Proteus中用80C51模拟4线SPI点亮OLED屏幕

在Proteus里用80C51模拟4线SPI控制OLED屏幕使其显示图案（汇编实现）。

Connor3093的博客 5002

从零部署思澈科技SiFli-Solution：避坑指南与实战排错

本文详细介绍了从零部署思澈科技SiFli-Solution开发环境的完整流程与实战排错指南。重点解析了Keil uVision5版本选择、Butterfli工具路径配置等关键步骤，并针对Keil路径报错、函数冲突等高频问题提供了具体解决方案，帮助开发者高效避坑，快速搭建稳定的嵌入式开发环境。

devops8pract的博客 529

函数模板与类模板(二)

2.1 类模板语法 2.2类模板与函数模板区别 2.3类模板中成员函数创建时机 2.4类模板对象做函数参数 2.5类模板与继承 2.6类模板成员函数类外实现 2.7类模板分文件编写 2.8类模板与友元

qq_61988957的博客 225

SAP入门技术分享四：模块化程序

SAP入门技术分享三：模块化程序

ITxiaoangzai的博客 1152

（1.1.28） C++模板：函数模板、类模板、模板与继承

C++模板：描述             C++提供一种模板的机制来减少代码重复。比如：对于同一样函数使用不同的数据类型，int,double,char等。C++模板属于“元编程”的范畴。 C++ 模板函数                  1.支持不同数据类型的函数重载： [cpp] view plaincopy #include    usi

JAVA成长之路 704

Notion卡顿救星：3分钟搞定DNS优化，手机电脑全平台加速指南

本文针对Notion访问慢和卡顿问题，提供了全平台DNS优化与Hosts文件修改的详细指南。通过更换优质DNS服务器或建立静态IP映射，可有效解决因网络延迟和域名解析导致的加载缓慢，实现手机与电脑端的快速加速，提升Notion使用流畅度。

v6b7n8m9q0的博客 1306

短信验证码逻辑漏洞学习——各种绕过姿势技巧

短信验证码逻辑漏洞学习——各种绕过姿势技巧

记录并分享学习安全的知识点.. 2555

每天一点C++——杂记230408

先介绍一下什么是左值，什么是右值。左值是表达是结束后仍然存在的持久化对象，可取地址，右值是表达式结束后就不再存在的临时对象，不可取地址。所有的具名变量活对象都是左值，而右值不具名。C++通过右值引用可以充分使用临时变量或者即将不使用的变量即右值资源，减少不必要的拷贝来提高效率。C++引入了右值引用&&，移动构造函数，移动赋值和std::move。

itlilyer的博客 462

[密码学实战]密评考试训练系统v1.0程序及密评参考题库（获取路径在文末）（二十四）

本系统将密码学理论与软件工程实践相结合，为密评备考提供了高效解决方案。随着《密码法》的深入实施，掌握密评知识将成为信息安全从业者的核心竞争力。立即开始您的密码安全专家之旅！（注：实际应用请以最新发布版本为准）

曼岛_的博客 797

【第六天】C++模板探秘：函数模板、类模板以及类型转换的深入解析

函数模板（类模板）：将功能相同，类型不同的函数（类）的类型抽象成虚拟的类型(函数类型和形参类型不具体指定)。不必定义多个函数，当调用函数（类实例化对 象）的时候，编译器自动将虚拟的类型 具体化。

m0_75045191的博客 1323

Camera2Demo

在Camera2 的基础上进行封装，使得Camera2一堆初始化逻辑与Activity分离，降低耦合度，完成预览拍照并保存的操作

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

C++ Primer阅读心得（第十六章）

1.模板实例化：C++中的模板是一个函数或者类的蓝图，编写了不局限于类型的通用代码。模板定义本身不参与编译，而是编译器根据模板的用户使用模板时提供的类型参数生成代码，再进行编译，这一过程被称为模板实例化。用户提供不同的类型参数，就会实例化出不同的代码。 2.函数模板：编译器可以根据用户使用函数模板时提供的实参，推断出函数模板的类型参数，这被称为模板实参推断。template int compar

lezardfu的专栏 1564

SIMATIC S7-1200, S7-1500 PID 控制[手册]

SIMATIC S7-1200, S7-1500 PID 控制[手册]

C++下篇-模板、STL（12）

模板：一个通用的函数或者类，写好磊大部分内容，里面只是把类型给用一个虚拟的类型来代替。在调用时，会根据实参的类型来替换模板中的类型 重载模板：写很多个模板名相同，但参数个数不同的函数或者类。在编译时，根据实际参数个数类型来匹配到一个模板的具体化 类模板的继承：将模板和继承的思想用到类上，可设计出实用而复制的类模板 STL=容器+迭代器+算法 容器：一种通用数据结构，可存储不同类型的数据对象...

chanleoo的博客 148

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0， 兼容Win7/Win10/WinXP，解压就可用。

模板与泛型

C++函数模板和类模板

心愿许得无限大 2228

C++类模板对象作为函数参数的设计策略与工程实践

在C++模板编程中，类模板实例化后的对象传递是连接泛型设计与具体应用的关键环节。其核心原理在于模板在编译时生成针对特定类型的代码，而如何设计接收这些对象的函数接口，直接影响着代码的耦合度与可测试性。从工程价值看，良好的参数传递设计能有效降低模块间依赖，提升代码复用性和测试便利性。常见的应用场景包括数据处理管道、算法库封装以及插件式架构中的回调机制。本文通过对比传递具体实例化类型、函数模板化、提取非模板接口及类型擦除等策略，深入探讨了在追求泛型灵活性的同时，如何通过接口设计实现松耦合，并自然融入了类模板对象和

weixin_30480075的博客 398
上一篇： 如何设计容器类
下一篇： C++ STL：vector和list
点赞 29
评论 3
书签 书签 161
xiaoding133
xiaoding133
博客等级 码龄19年 415粉丝 159原创
+ 关注 专栏目录 订阅专栏
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值