C++学习一模板（泛型）

最新推荐文章于 2024-11-02 14:05:25 发布
最新推荐文章于 2024-11-02 14:05:25 发布
阅读量69 收藏
点赞数 1
文章标签： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a130226123/article/details/132266055
版权

文章目录

函数模板和类模板

1.函数模板

template <class 类型参数1，class 类型参数2,……>
返回值类型 模板名 (形参表)
{
函数体
};

例如：交换函数

template <class T>
void Swap(T & x,T & y)
{
    T tmp = x;
    x = y;
    y = tmp;
}

template <class T1,class T2>
void print(T1 t1,T2 t2){
    cout << t1 << "  " << t2 << endl;
}

int main()
{
    int n = 1,m = 2;
    Swap(n,m); //编译器自动生成 void Swap(int & ,int & )函数
    print(n,m);
    double f = 1.2,g = 2.3;
    Swap(f,g); //编译器自动生成 void Swap(double & ,double & )函数
    print(f,g);
    return 0;
}

例如：求数组最大元素的MaxElement函数模板

template <class T>
T MaxElement(T a[], int size) //size是数组元素个数
{
    T tmpMax = a[0];
    for( int i = 1;i < size;++i)
        if( tmpMax < a[i] )
            tmpMax = a[i];
    return tmpMax;
}

int main(){
    int a[]  = {1,2,3,4,10,0};
    cout << MaxElement(a, sizeof(a)/ sizeof(int )) << endl;
}

不通过参数实例化函数模板

template <class T>
T Inc(T n)
{
    return 1 + n;
}
int main()
{
    cout << Inc<double>(4)/2; //输出 2.5
    return 0;
}

2.函数模板的重载

函数模板可以重载，只要它们的形参表或类型参数表不同即可。

template<class T1, class T2>
void print(T1 arg1, T2 arg2) {
    cout<< arg1 << " "<< arg2<<endl;
}
template<class T>
void print(T arg1, T arg2) {
    cout<< arg1 << " "<< arg2<<endl;
}
template<class T,class T2>
void print(T arg1, T arg2) {
    cout<< arg1 << " "<< arg2<<endl;
}

3.函数模板和函数的次序

在有多个函数和函数模板名字相同的情况下，编译器如下处理一条函数调用语句

  1. 先找参数完全匹配的普通函数(非由模板实例化而得的函数)。
  2. 再找参数完全匹配的模板函数。
  3. 再找实参数经过自动类型转换后能够匹配的普通函数。
  4. 上面的都找不到，则报错。
template <class T>
T Max( T a, T b) {
    cout << "TemplateMax" <<endl; return 0;
}
template <class T,class T2>
T Max( T a, T2 b) {
    cout << "TemplateMax2" <<endl; return 0;
}
double Max(double a, double b){
    cout << "MyMax" << endl;
    return 0;
}
int main() {
    int i=4, j=5;
    Max( 1.2,3.4); // 输出MyMax
    Max(i, j); //输出TemplateMax
    Max( 1.2, 3); //输出TemplateMax2
    return 0;
}

4.类模板

  1. 类模板的定义
template <class 类型参数1，class 类型参数2，……> //类型参数表
class 类模板名
{
	成员函数和成员变量
};

template <typename 类型参数1，typename 类型参数2，……>
//类型参数表
class 类模板名
{
	成员函数和成员变量
};
  1. 类模板里成员函数的写法：
template <class 类型参数1，class 类型参数2，……> //类型参数表
返回值类型 类模板名<类型参数名列表>::成员函数名（参数表）
{ 
	……
}
  1. 用类模板定义对象的写法：
    类模板名 <真实类型参数表> 对象名(构造函数实参表);

类模板示例： Pair类模板

template <class T1,class T2>
class Pair{
public:
    T1 key; //关键字
    T2 value; //值
    Pair(T1 k,T2 v):key(k),value(v){};  //构造函数
    bool operator < ( const Pair<T1,T2> & p) const;
};

template<class T1,class T2>
bool Pair<T1,T2>::operator<(const Pair<T1, T2> &p) const { //Pair的成员函数 operator <
    return key < p.key;
}

int main(){
    Pair<string,int> students("renbin",33);
    //实例化出一个类 Pair<string,int>
    cout << students.key << " " << students.value << "  " << students.operator<(students) << endl;
    return 0;
}
  1. 用类模板定义对象
    编译器由类模板生成类的过程叫类模板的实例化。由类模板实例化得到的类，叫模板类。
    同一个类模板的两个模板类是不兼容的
Pair<string,int> * p;
Pair<string,double> a;
p = & a; //wrong

函数模版作为类模板成员

template <class T>
class A
{
public:
    template<class T2>
    void Func( T2 t) { cout << t; } //成员函数模板
};
int main()
{
    A<int> a;
    a.Func('K'); //成员函数模板 Func被实例化
    a.Func("hello"); //成员函数模板 Func再次被实例化
    return 0;
}

类模板的“<类型参数表>”中可以出现非类型参数：

template <class T, int size>
class CArray{
    T array[size];
public:
    void Print( )
    {
        for( int i = 0;i < size; ++i)
            cout << array[i] << endl;
    }
};
CArray<double,40> a2;
CArray<int,50> a3; //a2和a3属于不同的类

4.类模板与派生

  1. 类模板从类模板派生
template <class T1,class T2>
class A {
    T1 v1; T2 v2;
};
template <class T1,class T2>
class B:public A<T2,T1> {
    T1 v3; T2 v4;
};
template <class T>
class C:public B<T,T> {
    T v5;
};

int main() {
    B<int,double> obj1;
    C<int> obj2;
    return 0;
}
  1. 类模板从模板类派生
template <class T1,class T2>
class A {
    T1 v1; T2 v2;
};
template <class T>
class B:public A<int,double> {
    T v;
};
int main() {
    B<char> obj1; //自动生成两个模板类：A<int,double> 和 B<char>
    return 0;
}
  1. 类模板从普通类派生
class A {
    int v1;
};
template <class T>
class B:public A { //所有从B实例化得到的类，都以A为基类
    T v;
};
int main() {
    B<char> obj1;
    return 0;
}
  1. 普通类从模板类派生
template <class T>
class A {
    T v1;
    int n;
};
class B:public A<int> {
    double v;
};
int main() {
    B obj1;
    return 0;
}

5.类模板与友元

  1. 函数、类、类的成员函数作为类模板的友元
void Func1() {}
class A {
};

class B {
public:
    void Func() {}
};

template<class T>
class Tmpl {
    friend void Func1();

    friend class A;

    friend void B::Func();
}; //任何从Tmp1实例化来的类，都有以上三个友元
  1. 函数模板作为类模板的友元
template <class T1,class T2>
class Pair
{
private:
    T1 key; //关键字
    T2 value; //值
public:
    Pair(T1 k,T2 v):key(k),value(v) { };
    bool operator < ( const Pair<T1,T2> & p) const;
    template <class T3,class T4>
    friend ostream & operator<< ( ostream & o,
                                  const Pair<T3,T4> & p);
};

template<class T1,class T2>
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const
{ //"小"的意思就是关键字小
    return key < p.key;
}
template <class T1,class T2>
ostream & operator<< (ostream & o,const Pair<T1,T2> & p)
{
    o << "(" << p.key << "," << p.value << ")" ;
    return o;
}

int main()
{
    Pair<string,int> student("Tom",29);
    Pair<int,double> obj(12,3.14);
    cout << student << " " << obj;
    return 0;
}
输出：
(Tom,29) (12,3.14)

任意从 template <class T1,class T2>ostream & operator<< (ostream & o,const Pair<T1,T2> & p)生成的函数，都是任意Pair摸板类的友元

  1. 函数模板作为类的友元
class A
{
    int v;
public:
    A(int n):v(n) { }
    template <class T>
    friend void Print(const T & p);
};
template <class T>
void Print(const T & p)
{
    cout << p.v;
}

int main() {
    A a(4);
    Print(a);
    return 0;
}
  1. 类模板作为类模板的友元
template <class T>
class B {
    T v;
public:
    B(T n):v(n) { }
    template <class T2>
    friend class A;
};
template <class T>
class A {
public:
    void Func( ) {
        B<int> o(10);
        cout << o.v << endl;
    }
};

int main()
{
    A< double > a;
    a.Func ();
    return 0;
}

6.类模板与静态成员变量

  1. 类模板中可以定义静态成员，那么从该类模板实例化得到的所有类，都包含同样的静态成员。
template <class T>
class A
{
private:
    static int count;
public:
    A() { count ++; }
    ~A() { count -- ; };
    A( A & ) { count ++ ; }
    static void PrintCount() { cout << count << endl; }
};

template<> int A<int>::count = 0;
template<> int A<double>::count = 0;
int main()
{
    A<int> ia;
    A<double> da;
    ia.PrintCount();
    da.PrintCount();
    return 0;
}
骑车的码农
关注
C++模板与泛型编程详解及实战应用
10-22
内容概要：本文详细介绍了C++模板和泛型编程的基础知识、进阶技术和实战应用。主要内容包括模板的概念与优势、函数模板和类模板的声明与实例化、模板元编程、SFINAE原则、模板特化与偏特化、类型推导与auto关键字、...
深入浅出C++模板编程：泛型编程的强大力量.md
09-07
C++模板编程及其在泛型编程中的强大应用。首先，文章介绍了模板的基础概念，包括函数模板和类模板，讲解了模板参数的类型和非类型参数，以及模板实例化的过程。接着，文章阐述了模板编程的优势，如代码复用、类型...
C++模板 vs Java 泛型
m0_61678439的博客
07-06 386
C++模板和Java泛型技术都是编程语言中用于实现代码复用的重要特性，它们允许程序员编写与数据类型无关的代码。尽管两者在目的上有相似之处，但在实现细节和使用方式上存在一些差异。
【C++】模板与泛型编程
Qiuhan_909的博客
03-29 959
1. 函数模板 2. 类模板 3. 非类型模板参数 4. 模板编译 5. 模板特化 6. 可变参数模板
C++模板与泛型
qq_63976098的博客
12-31 1132
C++函数模板、类模板详解
C++ 模板与泛型详解
ylh的博客
10-03 1875
/Code }模板形参表使用typename或者class定义都可以，没有任何区别，为了区分类的定义，一般使用typename//对于任意类型的两个对象相加，的函数模板 template < typename T > T sum(T a , T b) {}
【C++】模板（泛型编程）
qq_50563459的博客
01-22 589
将声明和实现写在同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制。利用具体化的模板，可以解决自定义类型的通用化，学习模板并不是为了写模板，而是再STL能够运用系统提供的模板。建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型。建立一个通用类，类中的成员 数据类型可以不具体制定，用虚拟的类型来表示。模板不可以直接使用，它只是一个框架，模板的通用不是万能的。
C++泛型编程之模板
m0_72532428的博客
05-27 1566
模板的知识详解
【C++】泛型模板（初级）
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
10-07 1036
函数模板和类模板
C++模板与泛型编程
Fighting！的博客
01-09 656
模板与泛型编程 模板是C++泛型编程的基础，一个模板就是一个创建类或函数的公式或者蓝图。 1、定义模板 1.1 函数模板(function template) 函数模板就像是一个公式，可用来生成针对特定类型的函数版本。例如下面的compare模板版本： template<typename T> int compare(const T &v1, const T &v2){ if(v1 < v2) return -1; if(v2 < v1) return
16 C++ 模板与泛型编程
surfaceyan的博客
05-17 615
模板是C++中泛型编程的基础。一个模板就是一个创建类或函数的蓝图或公式。当使用一个vector这个样的泛型类型，或find这样的泛型函数时，我们提供足够的星系，将蓝图转换为特定的类或函数。这种转换发生在编译时。function template    模板参数列表template parameter list   模板参数template parameter   模板实参template argument 非类型模板参数 nontype parameter inline和constexpr 类模板 实
C++//模板与泛型编程
weixin_43918519的博客
04-12 1034
1. 定义模板 模板参数列表的类型名(T)前必须加上关键字class或者typename。 模板示例如下： 编译器会根据实参类型实例化出一个特定版本的函数。 T称为模板类型参数，可以将类型参数看作类型说明符，就像使用内置类型或者类类型说明符一样使用。可以用来指明返回值类型或者作为函数参数类型。 除了类型参数，还可以在模板中定义非类型参数。非类型参数可以是整形，指向对象或者函数的指针或左值引用。绑定到指针或引用的非类型参数的实参必须具有静态生存周期。 在使用过程时，编译器会使用传入的字面常量的长度替换
C++程序设计与实践：11-模板和泛型编程.ppt
06-12
C++程序设计与实践：模板和泛型编程 C++ 程序设计与实践中，模板和泛型编程是非常重要的概念。模板是 C++ 的泛型机制，用来实现泛型编程。泛型编程是指不依赖于任何具体类型来编写通用代码，具体类型信息的提供是在...
C#中的泛型与C++中的模板
01-20
一个同事问我C#中有没有模板函数，他想写一个函数能够处理不同的类型，里面算法一样，如果要重载实现的话，造成大量重复的代码，而且扩展性不好。我说肯定有啊，你可以上网搜一下，结果他说没搜到，而我对C#根本不熟...
清华大学C++进阶讲义：第10章 泛型程序设计与C++标准模板库.pdf
02-16
### 清华大学C++进阶讲义：第10章 泛型程序设计与C++标准模板库 #### 泛型程序设计的基本概念 在计算机科学领域中，泛型程序设计是一种允许开发者编写能够处理多种数据类型的代码的技术。这种编程方式的核心在于...
c++中局部变量和全局变量同名，使用::访问全局变量
最新发布
weixin_43845922的博客
11-02 213
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 247
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2289
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 585
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值