C++中的类模板详解及示例

C++中的函数模板

对于类的声明来说,也有同样的问题。有时,有两个或多个类,其功能是相同的,仅仅是数据类型不同,如下面语句声明了一个类:


代码如下:

class Compare_int
{
 public:
  Compare(int a,int b)
  {
   x=a;
   y=b;
  }
  int max()
  {
   return (x>y)?x:y;
  }
  int min()
  {
   return (x<y)?x:y;
  }
 private:
  int x,y;
};

其作用是对两个整数作比较,可以通过调用函数成员max和min得到两个整数中的大者和小者。

如果想对两个浮点数(float型)做比较,另外在声明一个类:


代码如下:

class Compare_float
{
 public:
  Compare(float a,float b)
  {
   x=a;
   y=b;
  }
  float max()
  {
   return (x>y)?x:y;
  }
  float min()
  {
   return (x<y)?x:y;
  }
 private:
  float x,y;
};

显然这基本上是重复性的工作,应该有办法减少重复型的工作。C++中的类模板就是为了这类问题而增加的。

可以声明一个通用的类模板,它可以有一个或者多个虚函数的类型参数,


代码如下:

class Compare
{
 public:
  Compare(T a,T b)
  {
   x=a;
   y=b;
  }
  T max()
  {
   return(x>y)?x:y;
  }
  T min()
  {
   return(x<y)?x:y;
  }
 private:
  T x,y;
};

将此类模板和前面第一个Compare_int类作比较,可以看到有两处不同:
(1)

声明类模板时要增加一行,template<class 类型参数名>

template的意思是“模板”,是声明类模板时必须写的关键字。在template后面的尖括号内的内容是模板的参数表列,关键字class表示其后面的是类型参数。本例中,T就是一个类型参数名,这个名字是任意取的,只要是合法的标识符即可。

T并不是一个已存在的实际类型名,它只是一个虚拟类型参数名,在以后将被一个实际的类型名取代。

(2)

原有的类型名int换成虚拟类型参数名T。在建立类对象时,如果将实际类型指定为int型,编译系统就会用int取代所有的T,如果指定为float型,就用float取代所有的T。这样就能实现“一类多用”。

由于类模板包含类型参数,因此又称为参数化的类。如果说类是对象的抽象,对象是类的实例,则类模板时类的抽象,类是类模板的实例。利用类模板可以建立含各种数据类型的类。

那么,我们声明了一个类模板后,怎样使用它呢?

用类定义对象的一般方法:

Compare_int cmp1(4,7);       //Compare_int是已声明的类

其作用是建立一个Compare_int类的对象cmp1,将实参4和7分别赋给形参a和b,作为进行比较的两个整数。

用类模板定义对象的方法与此类似,但是不能直接写成

Compare cmp(4,7);               //Compare是类模板名

Compare是类模板名,而不是一个具体的类,类模板体中的类型T并不是一个实际的类型,只是一个虚拟的类型,无法用它去定义对象。必须用实际类型名去取代虚拟的类型,具体做法是:

Compare <int> cmp1(4,7);

即在类模板名之后在尖括号内指定实际的类型名,在进行编译时,编译系统就用int取代类模板中的类型参数T,这样就把类模板具体化了,或者说实例化了。

这时Compare <int>就相当于前面介绍的Compare_int类。

====================示例代码1.1====================

声明一个类模板,利用它分别实现两个整数、浮点数、和字符的比较,求出大数和小数


代码如下:

#include<iostream>
using namespace std;
template<class T>   //声明一个类模板,虚拟类型名为T
class Compare
{
 public:
  Compare(T a,T b)
  {
   x=a;
   y=b;
  }
  T max()
  {
   return(x>y)?x:y;
  }
  T min()
  {
   return(x<y)?x:y;
  }
 private:
  T x,y;
};
int main()
{
 Compare <int> cmp1(3,7);  //定义对象cmp1,用于两个整数的比较
 cout<<"Max : "<<cmp1.max()<<endl;
 cout<<"Min : "<<cmp1.min()<<endl<<endl;
  Compare <float> cmp2(45.89,88.76);//定义对象cmp2,用于两个浮点数的比较
 cout<<"Max : "<<cmp2.max()<<endl;
 cout<<"Min : "<<cmp2.min()<<endl;
 Compare <char> cmp3('a','A'); //定义对象cmp3,用于两个字符的比较
 cout<<"Max : "<<cmp3.max()<<endl;
 cout<<"Min : "<<cmp3.min()<<endl;
 return 0;
}

运行结果:

还有一个问题要说明:上面列出的类模板中的成员函数是在类模板内定义的。

如果改为在类模板外定义,不能用一般定义类成员函数的形式:

T compare::max(){....}             //不能这样定义类模板中的成员函数

而应当写成类模板的形式:


代码如下:

template<class T>
T Compare <T> ::max()
{
    return(x>y)?x:y;
}

第一行声明类模板,第二行左端的T是虚拟类型名,后面的Compare<T>是一个整体,是带参数的类。表示所定义的 max函数是在类Compare<T>的作用域内的。

在定义对象时,用户当然要指定实际的类型(图int),进行编译时就会将类模板中的虚拟类型名T全部用实际的类型代替。这样Compare<T>就相当于一个实际的类。

归纳一下使用时要注意的问题:

(1)在类声明前面加入一行,格式为

template<class 虚拟类型参数>

如:


代码如下:

template<class T>   //注意本行末尾没有分号
class Compare
{
……
}

(2)用类模板定义对象时用以下形式:

类模板名 <实际类型名> 对象名;

类模板名 <实际类型名> 对象名(实参列表);

如:


代码如下:

Compare <float> cmp2(45.89,88.76);//定义对象cmp2,用于两个浮点数的比较

(3)如果在类模板外定义成员函数,应写成类模板形式:

template <class  虚拟类型参数>

函数类型    类模板名 <虚拟类型参数>::成员函数名(函数形参表列){……}

(4)类模板的类型参数可以有一个或者多个,每个类型前面都必须加class,如:


代码如下:

template <class T1,class T2>
class someclass
{……};

在定义对象时,分别带入实际的类型名,如


代码如下:

someclass<int,double> obj;

(5)和使用类一样,使用类模板时要注意其作用域,只能在其有效作用域内用它定义对象。

如果类模板是在A文件开头定义的,则A文件范围内为有效作用域,可以在其中的任何地方使用类模板,但不能在B文件中使用类模板定义对象。

(6)模板可以有层次,一个类模板可以作为基类,派生出派生类。

(0)

相关推荐

  • C++聚合关系类的构造函数的调用顺序详解

    如图,表示一个聚合关系 下面就用简单的代码来实现 #pragma once class Engine { public: Engine(); ~Engine(); }; Engine.h #include <iostream> #include "Engine.h" using namespace std; Engine::Engine() { cout << "调用构造函数:Engine()" << endl; } Engine

  • C++类成员构造函数和析构函数顺序示例详细讲解

    对象并不是突然建立起来的,创建对象必须时必须同时创建父类以及包含于其中的对象.C++遵循如下的创建顺序: (1)如果某个类具体基类,执行基类的默认构造函数. (2)类的非静态数据成员,按照声明的顺序创建. (3)执行该类的构造函数. 即构造类时,会先构造其父类,然后创建类成员,最后调用本身的构造函数. 下面看一个例子吧 复制代码 代码如下: class c{public:    c(){ printf("c\n"); }protected:private:}; class b {pub

  • C++类静态成员与类静态成员函数详解

    当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享.各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少类对象无关.静态方法就是与该类相关的,是类的一种行为,而不是与该类的实例对象相关. 静态数据成员的用途之一是统计有多少个对象实际存在. 静态数据成员不能在类中初始化,实际上类定义只是在描述对象的蓝图,在其中指定初值是不允许的.也不能在类的构造函数中初始化该成员,因为静态数据成员为类的各个对象共享,否则每次创建一

  • c++类构造函数详解

    复制代码 代码如下: //一. 构造函数是干什么的 /*   类对象被创建时,编译系统对象分配内存空间,并自动调用该构造函数->由构造函数完成成员的初始化工作     eg: Counter c1; 编译系统为对象c1的每个数据成员(m_value)分配内存空间,并调用构造函数Counter( )自动地初始化对象,初始化之后c1的m_value值设置为0 故:构造函数的作用:初始化对象的数据成员.*/ class Counter       {      public:       // 类Co

  • C++类的静态成员初始化详细讲解

    记住:通常静态数据成员在类声明中声明,在包含类方法的文件中初始化.初始化时使用作用域操作符来指出静态成员所属的类.但如果静态成员是整型或是枚举型const,则可以在类声明中初始化!!! 复制代码 代码如下: #include <iostream>using namespace std;class test{public:static int num;};int test::num = 0;void main(){cout<<test::num <<endl;test::

  • C++中抽象类和接口的区别介绍

    1. 如果一个类B在语法上继承(extend)了类A, 那么在语义上类B是一个类A.2. 如果一个类B在语法上实现了(implement)接口I, 那么类B遵从接口I制定的协议. 使用abstract class的根本原因在于, 人们希望通过这样的方式, 表现不同层次的抽象. 而interface的本质是一套协议. 在程序设计的发展中, 人们又发现接口可以用来表示对行为的抽象, 不过, 这只是interface的一种用法不是其本质. 理论结合实际才是最好的学习方式, 不过在这里, 我只想举一些我

  • C++中的聚合类定义与用法分析

    本文实例讲述了C++中的聚合类.分享给大家供大家参考,具体如下: 聚合类是一种没有用户定义的构造函数,没有私有(private)和保护(protected)非静态数据成员,没有基类,没有虚函数.这样的类可以由封闭的大括号用逗号分隔开初始化列表.下列的代码在 C 和 C++ 具有相同的语法: struct C { int a; double b; }; struct D { int a; double b; C c; }; // initialize an object of type C wit

  • c++中string类成员函数c_str()的用法

    1.string类成员函数c_str()的原型: const char *c_str()const;//返回一个以null终止的c字符串 2.c_str()函数返回一个指向正规c字符串的指针,内容和string类的本身对象是一样的,通过string类的c_str()函数能够把string对象转换成c中的字符串的样式; 3.操作c_str()函数的返回值时,只能使用c字符串的操作函数,如:strcpy()等函数.因为,string对象可能在使用后被析构函数释放掉,那么你所指向的内容就具有不确定性.

  • C++中的类模板详解及示例

    C++中的函数模板 对于类的声明来说,也有同样的问题.有时,有两个或多个类,其功能是相同的,仅仅是数据类型不同,如下面语句声明了一个类: 复制代码 代码如下: class Compare_int{ public:  Compare(int a,int b)  {   x=a;   y=b;  }   int max()  {   return (x>y)?x:y;  }  int min()  {   return (x<y)?x:y;  } private:  int x,y;}; 其作用是

  • java开发中嵌套类的详解及实例

     java开发中嵌套类的详解 在java语言规范里面,嵌套类(Nested Classes)定义是: A nested class is any class whose declaration occurs within the body of another class or interface. A top level class is a class that is not a nested class. 说的简单一点,就是定义在类里面的类.一般把定义内部类的外围类成为包装类(enclos

  • C++单例类模板详解

    单例类 描述 指在整个系统生命期中,一个类最多只能有一个实例(instance)存在,使得该实例的唯一性(实例是指一个对象指针)  , 比如:统计在线人数 在单例类里,又分为了懒汉式和饿汉式,它们的区别在于创建实例的时间不同: 懒汉式 : 指代码运行后,实例并不存在,只有当需要时,才去创建实例(适用于单线程) 饿汉式 : 指代码一运行,实例已经存在,当时需要时,直接去调用即可(适用于多线程) 用法 将构造函数的访问属性设置为private, 提供一个GetInstance()静态成员函数,只能供

  • C#中的类继承详解

    目录 前言 类的继承 注意事项 寄语 总结 前言 在日常的程序编码工作中,我们的最终目标是完成公司交给自己的开发任务,核心目标是写出好代码. 那么什么是好代码? 高内聚,低耦合 想必从事编码工作的我们,基本都听说过这句话.那么什么样的代码是高内聚,又如何低耦合呢. 今天咱们就来了解下在C#这个高级语言中,是通过那些形式来表现的. 在目前的高级语言中,这三个特点是共通的,也是我们日常编码中要经常使用的.就是封装.继承.多态. 我们先来看看继承 类的继承 通过继承我们可以得到一个新的类,新类可以自己

  • pytorch中nn.Flatten()函数详解及示例

    torch.nn.Flatten(start_dim=1, end_dim=- 1) 作用:将连续的维度范围展平为张量. 经常在nn.Sequential()中出现,一般写在某个神经网络模型之后,用于对神经网络模型的输出进行处理,得到tensor类型的数据. 有俩个参数,start_dim和end_dim,分别表示开始的维度和终止的维度,默认值分别是1和-1,其中1表示第一维度,-1表示最后的维度.结合起来看意思就是从第一维度到最后一个维度全部给展平为张量.(注意:数据的维度是从0开始的,也就是

  • pandas中Timestamp类用法详解

    由于网上关于Timestamp类的资料比较少,而且官网上面介绍的很模糊,本文只是对如何创建Timestamp类对象进行简要介绍,详情请读者自行查阅文档. 以下有两种方式可以创建一个Timestamp对象: 1. Timestamp()的构造方法 import pandas as pd from datetime import datetime as dt p1=pd.Timestamp(2017,6,19) p2=pd.Timestamp(dt(2017,6,19,hour=9,minute=1

  • C++中友元类和嵌套类使用详解

    目录 前言 1. 友元类 2. 友元成员函数 3. 其他友元关系 3.1 成为彼此的友元类 3.2 共同的友元 4. 嵌套类 嵌套类的作用域和访问控制 作用域 前言 友元这个词,在学习类的时候肯定接触过,但是当时我们只用了很多友元函数. 友元有三种: 友元函数 友元类 友元类方法 类并非只能拥有友元函数,也可以将类作为友元.在这种情况下,友元类的所以方法都能访问原始类的私有成员和保护成员.另外,也可以做更严格的限制,只将特定的成员函数指定为另一个类的友元. 1. 友元类 假如我们有两个类:Tv电

  • C++类中的继承实例详解

    C++类中的继承实例详解 实例效果: 实现代码: #include<iostream> #include<string> using namespace std; class Person { public: Person(const char* name = "abc") :_name(name) { cout << "Person()" << endl; } Person(const Person& pp)

  • Java中IO流 RandomAccessFile类实例详解

    Java中IO流 RandomAccessFile类实例详解 RandomAccessFile java提供的对文件内容的访问,既可以读文件,也可以写文件. 支持随机访问文件,可以访问文件的任意位置. java文件模型,在硬盘上的文件是byte byte byte存储的,是数据的集合 打开文件,有两种模式,"rw"读写."r"只读:RandomAccessFile raf = new RandomAccessFile(file, "rw");,文

  • java 中 String format 和Math类实例详解

    java 中 String format 和Math类实例详解 java字符串格式化输出 @Test public void test() { // TODO Auto-generated method stub //可用printf(); System.out.println(String.format("I am %s", "jj")); //%s字符串 System.out.println(String.format("首字母是 %c",

随机推荐