189 8069 5689

什么是C++的函数模板与类模板

这篇文章运用简单易懂的例子给大家介绍什么是C++的函数模板与类模板，代码非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。

创新互联主要从事成都网站制作、网站设计、网页设计、企业做网站、公司建网站等业务。立足成都服务南乐,10多年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:13518219792

一、函数模板

1、定义

  template
  返回值类型 模板名 (形参表){
         函数体
  };

template 
T2 print(T1 arg1, T2 arg2)
{
    cout<< arg1 << " "<< arg2<
2、不通过参数实例化函数模板
#include 
using namespace std;
template 
T Inc(T n){
    return 1 + n;
}
int main(){
    cout << Inc(4)/2; //输出 2.5
    return 0;
}
3、函数模板可以重载，只要它们的形参表或类型参数表不同即可
template
void print(T1 arg1, T2 arg2) {
    cout<< arg1 << " "<< arg2<
void print(T arg1, T arg2) {
    cout<< arg1 << " "<< arg2<
void print(T arg1, T arg2) {
    cout<< arg1 << " "<< arg2<
4、函数模板和函数的次序
在有多个函数和函数模板名字相同的情况下，编译器如下处理一条函数调用语句
  • 先找参数完全匹配的普通函数(非由模板实例化而得的函数)。
  • 再找参数完全匹配的模板函数。
  • 再找实参数经过自动类型转换后能够匹配的普通函数。
  • 上面的都找不到，则报错。
template 
T Max( T a, T b) {
    cout << "TemplateMax" <
T Max( T a, T2 b) {
    cout << "TemplateMax2" <
5、匹配模板函数时，不进行类型自动转换
template
T myFunction( T arg1, T arg2)
{ cout<
二、类模板
1、定义
在定义类的时候，加上一个/多个类型参数。在使用类模板时，指定类型参数应该如何替换成具体类型，编译器据此生成相应的模板类。
    template  //类型参数表
   class 类模板名{
          成员函数和成员变量
   };
（1）类模板里成员函数的写法：
       template  //类型参数表
       返回值类型 类模板名<类型参数名列表>::成员函数名（参数表）{
            ……
       }
（2）用类模板定义对象的写法：
        类模板名 <真实类型参数表> 对象名(构造函数实参表);
// Pair类模板
template 
class Pair{
public:
    T1 key; //关键字
    T2 value; //值
    Pair(T1 k,T2 v):key(k),value(v) { };
    bool operator < ( const Pair & p) const;
};
template
bool Pair::operator < ( const Pair & p) const{  //Pair的成员函数 operator <
    return key < p.key;
}
int main(){
    Pair student("Tom",19);   //实例化出一个类 Pair
    cout << student.key << " " << student.value;
    return 0;
}
//输出：
Tom 19
2、用类模板定义对象
  • 编译器由类模板生成类的过程叫类模板的实例化。由类模板实例化得到的类，叫模板类。
  • 同一个类模板的两个模板类是不兼容的。
3、函数模版作为类模板成员
template 
class A{
    public:
        template
        void Func( T2 t) { cout << t; } //成员函数模板
};
4、类模板与非类型参数：类模板的“<类型参数表>”中可以出现非类型参数
template 
class CArray{
    T array[size];
public:
    void Print(){
        for( int i = 0;i < size; ++i)
        cout << array[i] << endl;
    }
};
CArray a2;
CArray a3;     //a2和a3属于不同的类
5、类模板与派生
（1）类模板从类模板派生
template               int main() {
class A {                                        B obj1;
    T1 v1; T2 v2;                                C obj2;
};                                               return 0;
template               }
class B:public A {                 class B:
    T1 v3; T2 v4;                             public A{
};                                            int v3; double v4;
template                         };
class C:public B {
    T v5;
};
（2）类模板从模板类派生
template 
class A {
    T1 v1; T2 v2;
};
template 
class B:public A {
    T v;
};
int main() {
    B obj1;     //自动生成两个模板类 ：A 和 B
    return 0;
}
（3）类模板从普通类派生
class A {
    int v1;
};
template 
    class B:public A { //所有从B实例化得到的类 ，都以A为基类
    T v;
};
int main() {
    B obj1;
    return 0;
}
（4）普通类从模板类派生
template 
class A {
    T v1;
    int n;
};
class B:public A {
    double v;
};
int main() {
    B obj1;
    return 0;
}
6、类模板与友员函数
（1）函数、类、类的成员函数作为类模板的友元
void Func1() { }
class A { };
class B{
    public:
        void Func() { }
};
template 
class Tmpl{
    friend void Func1();
    friend class A;
    friend void B::Func();
}; //任何从Tmp1实例化来的类 ，都有以上三个友元
（2）函数模板作为类模板的友元
#include 
#include 
using namespace std;
template 
class Pair{
    private:
        T1 key; //关键字
        T2 value; //值
    public:
        Pair(T1 k,T2 v):key(k),value(v) { };
        bool operator < ( const Pair & p) const;
        template 
        friend ostream & operator<< ( ostream & o,const Pair & p);
};
template 
bool Pair::operator < ( const Pair & p) const{ //"小"的意思就是关键字小
    return key < p.key;
}
template 
ostream & operator<< (ostream & o,const Pair & p){
    o << "(" << p.key << "," << p.value << ")" ;
    return o;
}
int main()
{
    Pair student("Tom",29);
    Pair obj(12,3.14);
    cout << student << " " << obj;
    return 0;
}
//输出：
(Tom,29) (12,3.14)
任意从 template 
       ostream & operator<< (ostream & o,const Pair & p)
生成的函数，都是任意Pair摸板类的友元
（3）函数模板作为类的友元
#include 
using namespace std;
class A
{
    int v;
public:
    A(int n):v(n) { }
    template 
    friend void Print(const T & p);
};
template 
void Print(const T & p){
    cout << p.v;
}
int main() {
    A a(4);
    Print(a);
    return 0;
}
//输出：4
（4）类模板作为类模板的友元
template 
class B {
    T v;
public:
    B(T n):v(n) { }
    template 
    friend class A;
};
template 
class A {
    public:
    void Func( )  {
        B o(10);
        cout << o.v << endl;
    }
};
7、类模板与静态成员变量
类模板中可以定义静态成员 ，那么从该类模板实例化得到的所有类 ，都包含同样的静态成员 。
#include 
using namespace std;
template 
class A{
    private:
        static int count;
    public:
        A() { count ++; }
        ~A() { count -- ; };
        A( A & ) { count ++ ; }
        static void PrintCount() { cout << count << endl; }
};
template<> int A::count = 0;
template<> int A::count = 0;
int main(){
    A ia;
    A da;
    ia.PrintCount();
    da.PrintCount();
    return 0;
}
//输出：1  1
关于什么是C++的函数模板与类模板就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。
            
            
                        

            网站栏目：什么是C++的函数模板与类模板            

            网站路径：http://cdxtjz.cn/article/jcchpi.html

其他资讯