6、 函数模板和类模板

﹏ヽ暗。殇╰゛Y 2022-05-20 02:13 366阅读 0赞

函数模板和类模板

前言

C++提供了函数模板(functiontemplate)。所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。

#

1）C++提供两种模板机制：函数模板、类模板

2）类属—— 类型参数化，又称参数模板

使得程序（算法）可以从逻辑功能上抽象，把被处理的对象（数据）类型作为参数传递。

总结：

Ø 模板把函数或类要处理的数据类型参数化，表现为参数的多态性，称为类属。

Ø 模板用于表达逻辑结构相同，但具体数据元素类型不同的数据对象的通用行为。

``

6.1函数模板 6.1.1为什么要有函数模板 #include <iostream> using namespace std; //函数的业务逻辑一样 //函数的参数类型 不一样 void mySwap(int &a, int &b) { int c = a; a = b; b = c; } void mySwap01(float &a, float &b) { float c = a; a = b; b = c; } //让 类型参数化 ===, 方便程序员进行编码 // 泛型编程 //template 告诉C++编译器 我要开始泛型编程了 .看到T, 不要随便报错 template <typename T> void myswap(T &a, T &b) { T c = a; a = b; b = c; cout << "hello ....我是模板函数 欢迎 calll 我" << endl; } //函数模板的调用 // 显示类型 调用 // 自动类型 推导 void main() { int x = 10; int y = 20; float x1 = 10.1; float y1 = 1.1; mySwap01(x1,y1); myswap<int>(x, y);//1 函数模板 显示类型 调用 printf("x:%f y:%f \n", x1, y1); mySwap(x,y); myswap(x,y); printf("x:%d y:%d \n", x, y); char a = 'a'; char b = 'b'; myswap<char>(a, b); //1 函数模板 显示类型 调用 printf("a:%c b:%c \n", a, b); } 6.1.2函数模板语法 函数模板定义形式 template <类型形式参数表> 类型形式参数的形式为： typenameT1, typename T2 ,…… , typename Tn 或 class T1 , class T2 , …… , classTn

函数模板调用

  1.                myswap<float>(a,b);     **  //显示类型调用**
  3.               myswap(a, b);                   **//自动数据类型推导**

6.1.3函数模板和模板函数

70

6.1.4函数模板做函数参数

  1. #include <iostream>
  2. using namespace std;
  4. template <typename T>
  5. int mySort(T *array, T size)
  6. {
  7.     T i, j;
  8.     T tmp;
  9.     if (NULL == array)
  10.     {
  11.         return -1;
  12.     }
  13.     //冒泡排序
  14.     for ( i = 0; i < size; i++)
  15.     {
  16.         for (j = i + 1; j < size; j++)
  17.         {
  18.             if (array[i] < array[j])//从大到小
  19.             {
  20.                 tmp = array[i];
  21.                 array[i] = array[j];
  22.                 array[j] = tmp;
  23.             }
  24.         }
  25.     }
  26.     return 0;
  27. }
  29. template <typename T>
  30. int myPrint(T *array, T size)
  31. {
  32.     T i = 0;
  33.     for ( i = 0; i < size; i++)
  34.     {
  35.         cout << array[i] << " ";
  36.     }
  37.     return 0;
  38. }
  39. int main()
  40. {
  41.     //int 类型
  42.     int myarray[] = { 11, 33, 44, 33, 22, 2, 3, 6, 9 };
  44.     int size = sizeof(myarray) / sizeof(*myarray);
  46.     mySort<int>(myarray, size); //显示类型调用
  48.     printf("排序之后\n");
  50.     myPrint<int>(myarray, size);
  52.     system("pause");
  53.     return 0;
  54. }

6.1.5函数模板遇上函数重载

函数模板和普通函数区别结论：

/*

函数模板不允许自动类型转化

普通函数能够进行自动类型转换

*/

函数模板和普通函数在一起，调用规则：

/*

  1.      1函数模板可以像普通函数一样被重载
  3.      2C++编译器优先考虑普通函数
  5.      3如果函数模板可以产生一个更好的匹配，那么选择模板
  7.      4可以通过空模板实参列表的语法限定编译器只通过模板匹配

*/

  1. #include <iostream>
  2. using namespace std; 
  4. //让 类型参数化 ===, 方便程序员进行编码
  5. // 泛型编程 
  6. //template 告诉C++编译器 我要开始泛型编程了 .看到T, 不要随便报错
  7. template <typename T>
  8. void myswap(T &a, T &b)//函数要求两个形参的类型 严格的要求类型匹配
  9. {
  10.     T c = a;
  11.     a = b;
  12.     b = c;
  13.     cout << "hello ....我是模板函数 欢迎 calll 我" << endl;
  14. }
  16. void myswap(int a, char c)
  17. {
  18.     cout << "a:" << a << "c:" << c << endl;
  19.     cout << "我是普通函数 欢迎来访" << endl;
  20. }
  21. //函数模板和普通函数区别结论：
  23. //函数模板 不允许自动类型转化
  24. //普通函数 能够进行自动类型转换
  26. //函数模板和普通函数在一起，调用规则：
  28. //1 函数模板可以像普通函数一样被重载
  29. //2 C++编译器优先考虑普通函数
  30. //3 如果函数模板可以产生一个更好的匹配，那么选择模板
  31. //4 可以通过空模板实参列表的语法限定编译器只通过模板匹配
  34. int main()
  35. {
  36.     int a = 10;
  37.     char c = 'c';
  38.     myswap(a, c); // 普通函数的调用:  可以进行隐式的类型转换 
  39.     myswap(c, a); //普通函数的调用:  可以进行隐式的类型转换 
  41.     myswap(a, a); // 函数模板函数的调用(本质:类型参数化): 将严格的按照类型进行匹配,不会进行自动类型转换
  44.     system("pause");
  45.     return 0;
  46. }

C++继承中重载、重写、重定义的区别：

重载overload：是函数名相同，参数列表不同 重载只是在类的内部存在。但是不能靠返回类型来判断。

重写override：也叫做覆盖。 子类重新定义父类中有相同名称和参数的虚函数。函数特征相同。但是具体实现不同，主要是在继承关系中出现的 。

重写需要注意：

1 被重写的函数 不能是static的。 必须是virtual的

2 重写函数必须有相同的类型，名称和参数列表

3 重写函数的访问修饰符可以不同。尽管virtual是private的，派生类中重写改写为public,protected也是可以的

重定义 (redefining)也叫做隐藏:

子类重新定义父类中有相同名称的非虚函数 ( 参数列表可以不同 ) 。

如果一个类，存在和父类相同的函数，那么，这个类将会覆盖其父类的方法，除非你在调用的时候，强制转换为父类类型，否则试图对子类和父类做类似重载的调用是不能成功的。

class Base {
private:
virtual void display() { cout<<”Base display()”<<endl; }
void say(){ cout<<”Base say()”<<endl; }
public:
void exec(){ display(); say(); }
void f1(string a) { cout<<”Base f1(string)”<<endl; }
void f1(int a) { cout<<”Base f1(int)”<<endl; } //overload，两个f1函数在Base类的内部被重载
};

class DeriveA:public Base{
public:
void display() { cout<<”DeriveA display()”<<endl; } //override，基类中display为虚函数，故此处为重写
void f1(int a,int b) { cout<<”DeriveA f1(int,int)”<<endl; } //redefining，f1函数在Base类中不为虚函数，故此处为重定义
void say() { cout<<”DeriveA say()”<<endl; } //redefining，同上
};

class DeriveB:public Base
{
public:
void f1(int a) { cout<<”DeriveB f1(int)”<<endl; } //redefining，重定义
};

int main(){
DeriveA a;
Base *b=&a;
b->exec(); //display():version of DeriveA call(polymorphism) //say():version of Base called(allways )

b里边的函数display被A类覆盖，但是say还是自己的。

a.exec(); //same result as last statement
a.say();
DeriveB c;
c.f1(1); //version of DeriveB called
}

执行结果：

C++ 重写重载重定义区别 - 漩涡鸣人 - 好记性不如烂笔头---漩涡鸣人

综上所述，总结如下：

1 成员函数重载特征：
a 相同的范围（在同一个类中）

b 函数名字相同

c 参数不同

d virtual关键字可有可无

2 重写（覆盖)是指派生类函数覆盖基类函数，特征是：

a 不同的范围，分别位于基类和派生类中

b 函数的名字相同

c 参数相同

d 基类函数必须有virtual关键字

3 重定义(隐藏)是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

a 如果派生类的函数和基类的函数同名，但是参数不同，此时，不管有无virtual，基类的函数被隐藏。

b 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有vitual关键字，此时，基类的函数被隐藏。

注意区分虚函数中的重载和重写：

  1. class A{
  3. public:
  4.       virtual int fun(){}
  5. };
  7. class B:public A{
  9.        int fun(int a){}  //这是重载而不是重写：
  11. }
  13. int mian()
  14. {
  17. }
  19. class B:public A{
  21.        int fun() // 从A继承来的 fun, 编译器会自己偷偷帮你加上
  22.        int fun(int a){} // 新的fun, 和前面的只是名字一样的重载函数, 不是虚函数
  23. }
  25. /*
  26. 函数模板不允许自动类型转化
  27. 普通函数能够进行自动类型转换
  28. */
  30. /*
  31. 1 函数模板可以像普通函数一样被重载
  32. 2 C++编译器优先考虑普通函数
  33. 3 如果函数模板可以产生一个更好的匹配，那么选择模板
  34. 4 可以通过空模板实参列表的语法限定编译器只通过模板匹配
  35. */
  38. #include "iostream"
  39. using namespace std;
  42. int Max(int a, int b)
  43. {
  44.     cout << "int Max(int a, int b)" << endl;
  45.     return a > b ? a : b;
  46. }
  48. template<typename T>
  49. T Max(T a, T b)
  50. {
  51.     cout << "T Max(T a, T b)" << endl;
  52.     return a > b ? a : b;
  53. }
  55. template<typename T>
  56. T Max(T a, T b, T c)
  57. {
  58.     cout << "T Max(T a, T b, T c)" << endl;
  59.     return Max(Max(a, b), c);
  60. }
  63. void main()
  64. {
  65.     int a = 1;
  66.     int b = 2;
  68.     cout << Max(a, b) << endl; //当函数模板和普通函数都符合调用时,优先选择普通函数
  69.     cout << Max<>(a, b) << endl; //若显示使用函数模板,则使用<> 类型列表
  71.     cout << Max(3.0, 4.0) << endl; //如果 函数模板产生更好的匹配 使用函数模板
  73.     cout << Max(5.0, 6.0, 7.0) << endl; //重载
  75.     cout << Max('a', 100) << endl;  //调用普通函数 可以隐式类型转换 
  76.     system("pause");
  77.     return;
  78. }

6.1.6 C++编译器模板机制剖析

思考：为什么函数模板可以和函数重载放在一块。C++编译器是如何提供函数模板机制的？

编译器编译原理

什么是gcc













gcc（GNU C Compiler）编译器的作者是Richard Stallman，也是GNU项目的奠基者。

什么是gcc：gcc是GNU Compiler Collection的缩写。最初是作为C语言的编译器（GNU C Compiler），现在已经支持多种语言了，如C、C++、Java、Pascal、Ada、COBOL语言等。

gcc支持多种硬件平台，甚至对Don Knuth 设计的 MMIX 这类不常见的计算机都提供了完善的支持

gcc主要特征







1）gcc是一个可移植的编译器，支持多种硬件平台

2）gcc不仅仅是个本地编译器，它还能跨平台交叉编译。

3）gcc有多种语言前端，用于解析不同的语言。

4）gcc是按模块化设计的，可以加入新语言和新CPU架构的支持

5）gcc是自由软件

gcc编译过程













预处理（Pre-Processing）

编译（Compiling）

汇编（Assembling）

链接（Linking）

Gcc *.c –o 1exe (总的编译步骤)

Gcc –E 1.c –o 1.i  //宏定义 宏展开

Gcc –S 1.i –o 1.s

Gcc –c 1.s –o 1.o

Gcc 1.o –o 1exe

结论：gcc编译工具是一个工具链。。。。

hello程序是一个高级Ｃ语言程序，这种形式容易被人读懂。为了在系统上运行hello.c程序，每条Ｃ语句都必须转化为低级机器指令。然后将这些指令打包成可执行目标文件格式，并以二进制形式存储器于磁盘中。

gcc常用编译选项












































选项

作用

-o

产生目标（.i、.s、.o、可执行文件等）

-c

通知gcc取消链接步骤，即编译源码并在最后生成目标文件

-E

只运行C预编译器

-S

告诉编译器产生汇编语言文件后停止编译，产生的汇编语言文件扩展名为.s

-Wall

使gcc对源文件的代码有问题的地方发出警告

-Idir

将dir目录加入搜索头文件的目录路径

-Ldir

将dir目录加入搜索库的目录路径

-llib

链接lib库

-g

在目标文件中嵌入调试信息，以便gdb之类的调试程序调试

练习
















gcc -E hello.c -o hello.i（预处理）

gcc -S hello.i -o hello.s（编译）

gcc -c hello.s -o hello.o（汇编）

gcc hello.o -o hello（链接）

以上四个步骤，可合成一个步骤

gcc hello.c -o hello（直接编译链接成可执行目标文件）

gcc -c hello.c或gcc -c hello.c -o hello.o（编译生成可重定位目标文件）

建议初学都加这个选项。下面这个例子如果不加-Wall选项编译器不报任何错误，但是得到的结果却不是预期的。

#include <stdio.h>

int main(void)

{

        printf(“2+1is %f”, 3);

        return 0;

}

Gcc编译多个.c

hello_1.h

hello_1.c

main.c

一次性编译

gcc  hello_1.c main.c –o newhello

独立编译

gcc -Wall -c main.c -o main.o

gcc -Wall -c hello_1.c -o hello_fn.o

gcc -Wall main.o hello_1.o -o newhello

函数模板机制结论

编译器并不是把函数模板处理成能够处理任意类的函数

编译器从函数模板通过具体类型产生不同的函数

编译器会对函数模板进行两次编译

第一次编译：在声明的地方对模板代码本身进行编译；

第二次编译：在调用的地方对参数替换后的代码进行编译。(这样就不会把函数模板处理成能够处理任意类的函数)

6.2类模板

6.2.1为什么需要类模板

类模板与函数模板的定义和使用类似，我们已经进行了介绍。有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同，如下面语句声明了一个类：

70 1

Ø 类模板用于实现类所需数据的类型参数化

Ø 类模板在表示如数组、表、图等数据结构显得特别重要，

这些数据结构的表示和算法不受所包含的元素类型的影响

6.2.2单个类模板语法

6.2.3继承中的类模板语法

" class="reference-link">70 2







//结论: 子类从模板类继承的时候,需要让编译器知道父类的数据类型具体是什么(数据类型的本质:固定大小内存块的别名)A<int>

//

class B : public A<int>

{

public:

         B(int i) : A<int>(i)

         {

 

         }

         void printB()

         {

                   cout<<”A:”<<t<<endl;

         }

protected:

private:

};

 

//模板与上继承

//怎么样从基类继承

//若基类只有一个带参数的构造函数,子类是如何启动父类的构造函数

void pintBB(B &b)

{

         b.printB();

}

void printAA(A<int>&a)//类模板做函数参数

{

          //

         a.getT();

}

 

void main()

{

         A<int>  a(100); //模板了中如果使用了构造函数,则遵守以前的类的构造函数的调用规则

         a.getT();

         printAA(a);

 

         B b(10);

         b.printB();

 

 

         cout<<”hello…”<<endl;

         system(“pause”);

         return ;

}

 
  1. #include <iostream>
  2. using namespace std;
  3. //A编程模板 类 
  4. //模板类  类型参数化
  7. //类模板的定义
  8. //类模板的使用
  9. //类模板 做函数参数
  11. //模板类
  12. template <typename T>
  13. class A
  14. {
  15. public:
  16.     A(T a)
  17.     {
  18.         this->a = a;
  19.     }
  20. public:
  21.     void printA()
  22.     {
  23.         cout << "a: " << a << endl;
  24.     }
  26. protected:
  27.     T a;
  28. };
  30. //从模板类 派生了 普通类
  31. // 模板类派生时, 需要具体化模板类. C++编译器需要知道 父类的数据类型具体是什么样子的
  32. //=====> 要知道父类所占的内存大小是多少 只有数据类型固定下来,才知道如何分配内存 
  33. class B:public A<int>
  34. {
  35. public:
  36.     B(int a = 10, int b = 20) :A<int>(a)
  37.     {
  38.         this->b = b;
  39.     }
  41.     void printB()
  42.     {
  43.         cout << "a:" << a << " b: " << b << endl;
  44.     }
  45. private:
  46.     int b;
  47. };
  50. //从模板类 派生 模板类
  51. template <typename T>
  52. class C:public A<T>
  53. {
  54. public:
  55.     C(T c, T a) :A<T>(a)
  56.     {
  57.         this->c = c;
  58.     }
  60.     void printC()
  61.     {
  62.         cout << "c:" << c << endl;
  63.     }
  65. private:
  66.     T c;
  67. };
  68. //类模板 做函数参数
  70. //参数 ,C++编译器 要求具体的类 所以所 要 A<int> &a 
  71. void UseA(A<int> &a)
  72. {
  73.     a.printA();
  74. }
  76. void main()
  77. {
  78.     B  b1(1, 2);
  79.     b1.printB();
  81.     C<int> c1(1, 2);
  82.     c1.printC();
  84.     //模板类(本身就是类型化的)====具体的类=====>定义具体的变量
  85.     A<int> a1(11), a2(20), a3(30); //模板类是抽象的  ====>需要进行 类型具体
  86.     a1.printA();
  88.     UseA(a1);
  89.     UseA(a2);
  90.     UseA(a3);
  92.     system("pause");
  93. }

6.2.4类模板语法知识体系梳理

6.2.4.1所有的类模板函数写在类的内部

  1. //重载+ <<运算符
  2. #include <iostream>
  3. using namespace std;
  5. class Complex
  6. {
  7.     friend ostream& operator << (ostream &out, Complex &obj);
  8. public:
  9.     Complex(int a, int b)
  10.     {
  11.         this->a = a;
  12.         this->b = b;
  13.     }
  14.     //重载+运算符
  15.     Complex operator+(Complex& c2)
  16.     {
  17.         Complex tmp(a+c2.a,b+c2.b);
  18.         return tmp;
  19.     }
  21.     void printCom()
  22.     {
  23.         cout << "a:" << a << " b: " << b << endl;
  24.     }
  25. private:
  26.     int a;
  27.     int b;
  28. };
  29. ostream& operator << (ostream &out, Complex &obj)
  30. {
  31.     out << "obj.a:" << obj.a << "obj.b:" << obj.b << endl;
  32.     return out;
  33. }
  34. void main()
  35. {
  36.     Complex c1(1,2);
  37.     Complex c2(2,4);
  39.     Complex c3 = c1 + c2;
  40.     //c1.operator+(c2);//成员函数
  41.     //Complex operator+(Complex& c2);
  42.     //c3.printCom();
  43.     cout <<  c3 << endl;
  44.     //友元函数 重载<<
  45.     //ostream& operator << (ostream &out, Complex &obj);
  46.     //成员函数
  47.     //这样的话必须拿到ostream类的源码 这样好在这个类里面写一个成员函数 但是实际上拿不到
  48.     //故友元函数用处之一就在此
  49.     //out.operator<<(c3);
  52.     system("pause");
  53. }
  59. //重载+ <<运算符
  60. //改成类模板
  61. #include <iostream>
  62. using namespace std;
  64. template <typename T>
  65. class Complex
  66. {
  67.     friend Complex MySub(Complex &obj1, Complex &obj2)
  68.     {
  69.         Complex tmp(obj1.a-obj2.a,obj1.b-obj2.b);
  70.         return tmp;
  71.     }
  73.     friend ostream& operator << (ostream &out, Complex &obj)
  74.     {
  75.         out << "obj.a:" << obj.a << "obj.b:" << obj.b << endl;
  76.         return out;
  77.     }
  78. public:
  79.     Complex(T a, T b)
  80.     {
  81.         this->a = a;
  82.         this->b = b;
  83.     }
  84.     //重载+运算符
  85.     Complex operator+(Complex& c2)
  86.     {
  87.         Complex tmp(a+c2.a,b+c2.b);
  88.         return tmp;
  89.     }
  91.     void printCom()
  92.     {
  93.         cout << "a:" << a << " b: " << b << endl;
  94.     }
  95. private:
  96.     T a;
  97.     T b;
  98. };
  100. //友元函数实现写在类的外部 报错
  101. //    缺少 类模板 "Complex" 的参数列表
  103. //ostream& operator << (ostream &out, Complex &obj)
  104. //{
  105. //    out << "obj.a:" << obj.a << "obj.b:" << obj.b << endl;
  106. //    return out;
  107. //}
  109. void main()
  110. {
  111.     Complex<int> c1(1,2);
  112.     Complex<int>  c2(2, 4);
  114.     Complex<int>  c3 = c1 + c2;
  115.     //c1.operator+(c2);//成员函数
  116.     //Complex operator+(Complex& c2);
  117.     //c3.printCom();
  118.     cout <<  c3 << endl;
  119.     //友元函数 重载<<
  120.     //ostream& operator << (ostream &out, Complex &obj);
  121.     //成员函数
  122.     //这样的话必须拿到ostream类的源码 这样好在这个类里面写一个成员函数 但是实际上拿不到
  123.     //故友元函数用处之一就在此
  124.     //out.operator<<(c3);
  126.     //运算符重载的正规写法 
  127.     // 重载 << >> 只能用友元函数  ,其他运算符重载 都要写成成员函数 , 不要滥用友元函数
  128.     {
  129.         Complex<int> c4 = MySub(c1, c2);
  130.         cout << c4 << endl;
  132.     }
  133.     system("pause");
  134. }

6.2.4.2所有的类模板函数写在类的外部，在一个cpp中

  1. #include <iostream>
  2. using namespace std;
  4. //1）需要在类前增加类的前置声明函数的前置声明
  5. template <typename T>
  6. class Complex; //类的前置声明
  8. template <typename T>
  9. Complex<T> MySub(Complex<T> &obj1, Complex<T> &obj2);
  12. template <typename T>
  13. class Complex
  14. {
  15.     //重载<< 运算符
  16.     //友元函数：用友元函数重载<<>>
  17.     //friend ostream& operator<<<T> (ostream &out, Complex<T>&c3) ;
  18.     friend ostream &operator<< <T> (ostream &out, Complex &c3);
  20.     //2）类的内部声明必须写成: 
  21.     friend Complex MySub<T>(Complex &obj1, Complex &obj2);
  23. public:
  24.     Complex(T a, T b);
  25.     void printCom();
  26.     Complex operator+ (Complex &c2);
  27. private:
  28.     T    a;
  29.     T    b;
  30. };
  32. //构造函数的实现写在了类的外部
  33. template <typename T>
  34. Complex<T>::Complex(T a, T b)
  35. {
  36.     this->a = a;
  37.     this->b = b;
  38. }
  40. template <typename T>
  41. void Complex<T>::printCom()
  42. {
  43.     cout << "a:" << a << "b:" << b << endl;
  44. }
  46. //重载+ 运算符
  47. //1.参数 2.函数名 3.返回值
  48. template <typename T>
  49. Complex<T> Complex<T>::operator+(Complex<T> &c2)
  50. {
  51.     Complex tmp(a + c2.a, b + c2.b);
  52.     return tmp;
  53. }
  55. //友元函数 实现 << 运算符重载
  56. template <typename T>
  57. ostream & operator<<(ostream &out, Complex<T> &c3)
  58. {
  59.     out << c3.a << " + " << c3.b << "i" << endl;
  60.     return out;
  61. }
  62. //滥用 友元函数
  63. //3）友元函数实现必须写成：
  64. template <typename T>
  65. Complex<T> MySub(Complex<T> &obj1, Complex<T> &obj2)
  66. {
  67.     //Complex<T> 这个<T>不能少
  68.     Complex<T>  tmp(obj1.a - obj2.a, obj1.b - obj2.b);
  69.     return tmp;
  70. }
  71. void main()
  72. {
  73.     //需要把模板类 进行具体化以后  才能定义对象  C++编译器要分配内存
  74.     Complex<int>    c1(1, 2);
  75.     Complex<int>    c2(3, 4);
  77.     Complex<int> c3 = c1 + c2;
  78.     //c3.printCom();
  79.     cout << c3 << endl;
  81.     //滥用友元函数
  82.     {
  83.         //4）友元函数调用必须写成
  84.         Complex<int> c4 = MySub<int>(c1, c2);
  85.         cout << c4 << endl;
  87.     }
  91.     cout << "hello..." << endl;
  92.     system("pause");
  93.     return;
  94. }

//构造函数没有问题

//普通函数没有问题

//友元函数：用友元函数重载<<>>

// friend ostream& operator<<(ostream &out, Complex&c3) ;

//友元函数：友元函数不是实现函数重载（非<<>>）滥用友元函数

//1）需要在类前增加类的前置声明函数的前置声明

template

class Complex;

template

Complex mySub(Complex&c1, Complex&c2);

  1. //2）类的内部声明必须写成:

friend ComplexmySub (Complex&c1, Complex&c2);

//3）友元函数实现必须写成：

template

ComplexmySub(Complex&c1, Complex&c2)

{

  1.               Complex<T> tmp(c1.a - c2.a,c1.b-c2.b);
  3.               returntmp;

}

//4）友元函数调用必须写成

Complex c4 = mySub(c1,c2);

cout<<c4;

结论：友元函数只用来进行左移友移操作符重载。

6.2.4.3所有的类模板函数写在类的外部，在不同的.h和.cpp中,

也就是类模板函数说明和类模板实现分开

//类模板函数

构造函数

普通成员函数

友元函数

用友元函数重载<<>>;

用友元函数重载非<<>>

//要包含.cpp

6.2.4.4总结

归纳以上的介绍，可以这样声明和使用类模板：

1) 先写出一个实际的类。由于其语义明确，含义清楚，一般不会出错。

2) 将此类中准备改变的类型名(如int要改变为float或char)改用一个自己指定的虚拟类型名(如上例中的numtype)。

3) 在类声明前面加入一行，格式为：

template

如：

template //注意本行末尾无分号

class Compare

  1. \{…\}; //类体

4) 用类模板定义对象时用以下形式：

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

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

如：

Compare cmp;

Compare cmp(3,7);

5) 如果在类模板外定义成员函数，应写成类模板形式：

template

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

关于类模板的几点说明：

1) 类模板的类型参数可以有一个或多个，每个类型前面都必须加class，如：

template

class someclass

{…};

在定义对象时分别代入实际的类型名，如：

someclass obj;

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

3) 模板可以有层次，一个类模板可以作为基类，派生出派生模板类。

结论：友元函数只用来进行左移友移操作符重载。

6.2.5类模板中的static关键字

  1. /*
  2. dm10_类模板中的static关键字
  3. 编译器并不是把函数模板处理成能够处理任意类的函数
  4. 编译器从函数模板通过具体类型产生不同的函数
  5. 编译器会对函数模板进行两次编译
  6. 在声明的地方对模板代码本身进行编译；在调用的地方对参数替换后的代码进行编译。
  7. */
  9. #include <iostream>
  10. using namespace std;
  12. template <typename T>
  13. class AA
  14. {
  15. public:
  16.     static T m_a;
  18. private:
  20. };
  23. /*
  24. 类模板相当于第一次编译留下编译头，第二次遇到相应类型,在编译所需要类
  25. class AA1
  26. {
  27. public:
  28. static int m_a;
  29. protected:
  30. private:
  31. };
  32. int AA1::m_a  = 0;
  35. class AA2
  36. {
  37. public:
  38. static char m_a;
  39. protected:
  40. private:
  41. };
  42. char AA2::m_a  = 0;
  43. */
  44. template <typename T>
  45. T AA<T>::m_a = 0;//静态变量的初始化
  47. void main()
  48. {
  49.     AA<int> a1, a2, a3;
  50.     a1.m_a = 10;
  51.     a2.m_a++;
  52.     a3.m_a++;
  54.     cout << AA<int>::m_a << endl;
  56.     AA<char> b1, b2, b3;
  57.     b1.m_a = 'a';
  58.     b2.m_a++;
  59.     b2.m_a++;
  61.     cout << AA<char>::m_a << endl;
  63.     cout << "hello..." << endl;
  64.     system("pause");
  65.     return;
  66. }

Ø 从类模板实例化的每个模板类有自己的类模板数据成员，该模板类的所有对象共享一个static数据成员

Ø 和非模板类的static数据成员一样，模板类的static数据成员也应该在文件范围定义和初始化

Ø 每个模板类有自己的类模板的static数据成员副本

70 3

70 4 70 5
70 6

原理图：

70 7

6.3类模板在项目开发中的应用

小结

Ø 模板是C++类型参数化的多态工具。C++提供函数模板和类模板。

Ø 模板定义以模板说明开始。类属参数必须在模板定义中至少出现一次。

Ø 同一个类属参数可以用于多个模板。

Ø 类属参数可用于函数的参数类型、返回类型和声明函数中的变量。

Ø 模板由编译器根据实际数据类型实例化，生成可执行代码。实例化的函数。

模板称为模板函数；实例化的类模板称为模板类。

Ø 函数模板可以用多种方式重载。

Ø 类模板可以在类层次中使用。

训练题

1） 请设计一个数组模板类（MyVector），完成对int、char、Teacher类型元素的管理。
需求

设计:

类模板构造函数拷贝构造函数<<[] 重载=操作符

a2=a1

  1.                         实现

2） 请仔细思考：

a) 如果数组模板类中的元素是Teacher元素时，需要Teacher类做什么工作

b) 如果数组模板类中的元素是Teacher元素时，Teacher类含有指针属性哪？

十分重要的一个例子：

  1. //MyVector.h
  2. #pragma once
  3. #include <iostream>
  4. using namespace std;
  6. template <typename T>
  7. class MyVector
  8. {
  9.     //重载<< 小心<T>
  10.     friend ostream& operator <<<T> (ostream &out, MyVector<T> &obj);
  11. public:
  12.     MyVector(int size);//有参构造函数
  14.     MyVector(const MyVector &obj);//拷贝构造函数
  16.     ~MyVector();//析构函数
  17. public:
  18.     //重载[]运算符
  19.     T& operator[](int index);
  21.     //重载=运算符
  22.     MyVector& operator=(const MyVector &obj);
  23. public:
  24.     int getLen()
  25.     {
  26.         return m_len;
  27.     }
  29. protected:
  30.     T *m_space;
  31.     int m_len;
  32. };
  35. //MyVector.hpp
  36. #include "MyVector.h"
  37. #include <iostream>
  38. using namespace std;
  40. //重载<< 运算符
  41. template <typename T>
  42. ostream& operator << (ostream &out, MyVector<T> &obj)
  43. {
  44.     for (int i = 0; i < obj.m_len; i++)
  45.     {
  46.         out << obj.m_space[i] << " ";
  47.         //out<<t1 t1是Teacher类对象
  49. //当MyVector<char> 或者MyVector<int>
  50.         //obj.m_space[i]可以直接就是char类型或者int类型 这个是能直接打印出来的
  51.         //而out<<t1 t1是Teacher类对象  obj.m_space[]==>t1对象 而t1对象是无法打印出来的,所以需要Teacher封装的函数有重载<<运算符函数
  52.     }
  53.     out << endl;
  54.     return out;
  55. }
  57. //有参构造函数
  58. //MyVector<int> myv1(10);
  59. template <typename T>
  60. MyVector<T>::MyVector(int size)
  61. {
  62.     m_space = new T[size];
  63.     m_len = size;
  64. }
  66. //拷贝构造函数
  67. template <typename T>
  68. MyVector<T>::MyVector(const MyVector &obj)
  69. {
  70.     //1 根据对象的大小分配内存
  71.     m_len = obj.m_len;
  72.     m_space = new T[m_len];
  74.     //copy数据
  75.     for (int i = 0; i < m_len; i++)
  76.     {
  77.         m_space[i] = obj.m_space[i];
  78.     }
  80. }
  81. //析构函数
  82. template <typename T>
  83. MyVector<T>::~MyVector()
  84. {
  85.     if (m_space !=NULL)
  86.     {
  87.         delete[] m_space;
  88.         m_space = NULL;
  89.         m_len = 0;
  90.     }
  91. }
  94. //重载[]运算符
  95. //5) 如果在类模板外定义成员函数，应写成类模板形式：
  96. //template <class 虚拟类型参数>
  97. //函数类型类模板名<虚拟类型参数>::成员函数名(函数形参表列) { … }
  99. template <typename T>
  100. T& MyVector<T>::operator[] (int index)
  101. {
  102.     return m_space[index];
  103. }
  106. //重载=运算符
  107. // a3 = a2 = a1;
  108. template <typename T>
  109. MyVector<T>& MyVector<T>::operator=(const MyVector<T> &obj)
  110. {
  111.     //1 释放旧的内存
  112.     if (m_space != NULL)
  113.     {
  114.         delete[] m_space;
  115.         m_space = NULL;
  116.         m_len = 0;
  117.     }
  118.     //2 根据obj分配内存
  119.     m_len = obj.m_len;
  120.     m_space = new T[m_len];
  122.     //3 拷贝数据
  123.     for (int i = 0; i < m_len; i++)
  124.     {
  125.         m_space[i] = obj[i];
  126.     }
  128.     return *this;//返回本身
  129. }
  130. ///
  131. //main.cpp
  132. #define _CRT_SECURE_NO_WARNINGS
  133. #include "MyVector.hpp"//类模板会二次编译  可写成hpp
  134. #include <iostream>
  135. using namespace std;
  137. //1  优化Teacher类, 属性变成 char *panme, 内置函数里面 分配内存
  138. //2  优化Teacher类,析构函数 释放panme指向的内存空间
  139. //3  优化Teacher类,避免浅拷贝 重载= 重写拷贝构造函数 
  140. //4  优化Teacher类,在Teacher增加 << 
  141. //5  在模板数组类中,存int char Teacher Teacher*(指针类型)
  144. class Teacher
  145. {
  146.     friend ostream &operator<<(ostream &out, const Teacher &obj);
  147. public:
  148.     Teacher()
  149.     {
  150.         age = 33;
  151.         strcpy(name,"");
  152.     }
  154.     Teacher(char *name, int age)
  155.     {
  156.         this->age = age;
  157.         strcpy(this->name,name);
  158.     }
  159.     void printT()
  160.     {
  161.         cout << name << ", " << age << endl;
  162.     }
  163. public:
  164.     int age;
  165.     char name[32];
  167. };
  168. ostream &operator<<(ostream &out, const Teacher &obj)
  169. {
  170.     out << "obj.name:" << obj.name << "obj.age :" <<obj.age << endl;
  171.     return out;
  172. }
  173. //数组模板类（MyVector）完成对int类型元素的管理
  174. void main01()
  175. {
  176.     MyVector<int> myv1(10);
  178.     for (int i = 0; i < 10; i++)
  179.     {
  180.         myv1[i] = i + 1;
  181.         cout << myv1[i] << " ";
  182.     }
  183.     cout << endl;
  186.     MyVector<int> myv2 = myv1;
  187.     for (int i = 0; i < 10; i++)
  188.     {
  189.         cout << myv2[i] << " ";
  190.     }
  191.     cout << endl;
  192.     cout << myv2 << endl;
  193.     //重载<<
  194.     //ostream& operator << (ostream &out, MyVector<T> &obj)
  197.     cout << "hello..." << endl;
  198.     system("pause");
  199.     return;
  200. }
  201. //数组模板类（MyVector）完成对char类型元素的管理
  202. void main02()
  203. {
  204.     MyVector<char> myv1(10);
  205.     myv1[0] = 'a';
  206.     myv1[1] = 'b';
  207.     myv1[2] = 'c';
  208.     myv1[3] = 'd';
  210.     cout << myv1;
  212.     system("pause");
  213. }
  215. //数组模板类（MyVector）完成对Teacher类型元素的管理
  216. void main()
  217. {
  218.     Teacher t1("t1", 31), t2("t2", 32), t3("t3", 33), t4("t4", 34);
  220.     MyVector<Teacher> tArray(4);
  222.     tArray[0] = t1;
  223.     tArray[1] = t2;
  224.     tArray[2] = t3;
  225.     tArray[3] = t4;
  227.     for (int i = 0; i<4; i++)
  228.     {
  229.         Teacher tmp = tArray[i];
  230.         tmp.printT();
  231.     }
  232.     //结论1：如果把Teacher放入到MyVector数组中，并且Teacher类的属性含有指针，就是出现//深拷贝和浅拷贝的问题。
  233.     //    结论2：需要Teacher封装的函数有：
  234.     //    1）    重写拷贝构造函数
  235.     //    2）    重载等号操作符
  236.     //    3）    重载左移操作符。
  238.     cout << tArray;
  242.     system("pause");
  243. }









class Teacher

{

    friend ostream &operator<<(ostream &out, const Teacher &obj);

public:

    Teacher(char name, int age)

    {

       this->age = age;

       strcpy(this->name, name);

    }

 

    Teacher()

    {

       this->age = 0;

       strcpy(this->name, “”);

    }

   

private:

    int age;

    char name[32];

};

class Teacher

{

    friend ostream &operator<<(ostream &out, const Teacher &obj);

public:

    Teacher(char name, int age)

    {

       this->age = age;

       strcpy(this->name, name);

    }

 

    Teacher()

    {

       this->age = 0;

       strcpy(this->name, “”);

    }

   

private:

    int age;

    char*pname;

};

结论1：如果把Teacher放入到MyVector数组中，并且Teacher类的属性含有指针，就是出现深拷贝和浅拷贝的问题。

结论2：需要Teacher封装的函数有：

1） 重写拷贝构造函数

2） 重载等号操作符

3） 重载左移操作符。

理论提高：所有容器提供的都是值（value）语意，而非引用（reference）语意。容器执行插入元素的操作时，内部实施拷贝动作。所以STL容器内存储的元素必须能够被拷贝（必须提供拷贝构造函数）。

3） 请从数组模板中进行派生










 

//演示从模板类派生一般类

#include “MyVector.cpp”

 

class MyArray01 : public MyVector<double>

{

public:

         MyArray01(int len) : MyVector<double>(len)

         {

                   ;

         }

protected:

private:

};

 

 

//演示从模板类派生模板类 //BoundArray

template <typename T>

class MyArray02 : public MyVector<T>

{

public:

         MyArray02(int len) : MyVector<double>(len)

         {

                   ;

         }

protected:

private:

};

测试案例：

 

//演示从模板类继承模板类

void main()

{

         MyArray02<double> dArray2(10);

         dArray2[1] = 3.15;

 

}

 

 

//演示从模板类继承一般类

void main11()

{

         MyArray01 d_array(10);

 

         for (int i=0; i<d_array.getLen(); i++)

         {

                   d_array[i] = 3.15;

         }

 

         for (int i=0; i<d_array.getLen(); i++)

         {

                   cout << d_array[i] << “ “;

         }

 

         cout<<”hello…”<<endl;

         system(“pause”);

         return ;

}

 

6.4作业

封装你自己的数组类；设计被存储的元素为类对象；

思考：类对象的类，应该实现的功能。

//1 优化Teacher类, 属性变成 char*panme, 构造函数里面分配内存

//2 优化Teacher类,析构函数释放panme指向的内存空间

//3 优化Teacher类,避免浅拷贝重载= 重写拷贝构造函数

//4 优化Teacher类,在Teacher增加<<

//5 在模板数组类中,存int charTeacher Teacher*(指针类型)

//=====>stl 容器的概念

  1. //MyVector.h
  2. #pragma once
  3. #include <iostream>
  4. using namespace std;
  6. template <typename T>
  7. class MyVector
  8. {
  9.     //重载<< 小心<T>
  10.     friend ostream& operator <<<T> (ostream &out, MyVector<T> &obj);
  11. public:
  12.     MyVector(int size);//有参构造函数
  14.     MyVector(const MyVector &obj);//拷贝构造函数
  16.     ~MyVector();//析构函数
  17. public:
  18.     //重载[]运算符
  19.     T& operator[](int index);
  21.     //重载=运算符
  22.     MyVector& operator=(const MyVector &obj);
  23. public:
  24.     int getLen()
  25.     {
  26.         return m_len;
  27.     }
  29. protected:
  30.     T *m_space;
  31.     int m_len;
  32. };
  34. ///
  35. //MyVector.hpp
  36. #include "MyVector.h"
  37. #include <iostream>
  38. using namespace std;
  40. //重载<< 运算符
  41. template <typename T>
  42. ostream& operator << (ostream &out, MyVector<T> &obj)
  43. {
  44.     for (int i = 0; i < obj.m_len; i++)
  45.     {
  46.         out << obj.m_space[i] << " ";
  47.         //当MyVector<char> 或者MyVector<int>
  48.         //obj.m_space[i]可以直接就是char类型或者int类型 这个是能直接打印出来的
  49.         //而out<<t1 t1是Teacher类对象  obj.m_space[]==>t1对象 而t1对象是无法打印出来的,所以需要Teacher封装的函数有重载<<运算符函数
  50.     }
  51.     out << endl;
  52.     return out;
  53. }
  55. //有参构造函数
  56. //MyVector<int> myv1(10);
  57. template <typename T>
  58. MyVector<T>::MyVector(int size)
  59. {
  60.     m_space = new T[size];
  61.     m_len = size;
  62. }
  64. //拷贝构造函数
  65. template <typename T>
  66. MyVector<T>::MyVector(const MyVector &obj)
  67. {
  68.     //1 根据对象的大小分配内存
  69.     m_len = obj.m_len;
  70.     m_space = new T[m_len];
  72.     //copy数据
  73.     for (int i = 0; i < m_len; i++)
  74.     {
  75.         m_space[i] = obj.m_space[i];
  76.     }
  78. }
  79. //析构函数
  80. template <typename T>
  81. MyVector<T>::~MyVector()
  82. {
  83.     if (m_space !=NULL)
  84.     {
  85.         delete[] m_space;
  86.         m_space = NULL;
  87.         m_len = 0;
  88.     }
  89. }
  92. //重载[]运算符
  93. //5) 如果在类模板外定义成员函数，应写成类模板形式：
  94. //template <class 虚拟类型参数>
  95. //函数类型类模板名<虚拟类型参数>::成员函数名(函数形参表列) { … }
  97. template <typename T>
  98. T& MyVector<T>::operator[] (int index)
  99. {
  100.     return m_space[index];
  101. }
  104. //重载=运算符
  105. // a3 = a2 = a1;
  106. template <typename T>
  107. MyVector<T>& MyVector<T>::operator=(const MyVector<T> &obj)
  108. {
  109.     //1 释放旧的内存
  110.     if (m_space != NULL)
  111.     {
  112.         delete[] m_space;
  113.         m_space = NULL;
  114.         m_len = 0;
  115.     }
  116.     //2 根据obj分配内存
  117.     m_len = obj.m_len;
  118.     m_space = new T[m_len];
  120.     //3 拷贝数据
  121.     for (int i = 0; i < m_len; i++)
  122.     {
  123.         m_space[i] = obj[i];
  124.     }
  126.     return *this;//返回本身
  127. }
  128. //
  129. //main.cpp
  130. #define _CRT_SECURE_NO_WARNINGS
  131. #include "MyVector.hpp"//类模板会二次编译  可写成hpp
  132. #include <iostream>
  133. using namespace std;
  135. //1  优化Teacher类, 属性变成 char *panme, 内置函数里面 分配内存
  136. //2  优化Teacher类,析构函数 释放panme指向的内存空间
  137. //3  优化Teacher类,避免浅拷贝 重载= 重写拷贝构造函数 
  138. //4  优化Teacher类,在Teacher增加 << 
  139. //5  在模板数组类中,存int char Teacher Teacher*(指针类型)
  141. //结论1：如果把Teacher放入到MyVector数组中，并且Teacher类的属性含有指针，就是出现//深拷贝和浅拷贝的问题。
  142. //    结论2：需要Teacher封装的函数有：
  143. //    1）    重写拷贝构造函数
  144. //    2）    重载等号操作符
  145. //    3）    重载左移操作符。
  146. class Teacher
  147. {
  148.     //    3）    重载左移操作符
  149.     friend ostream &operator<<(ostream &out, const Teacher &obj)
  150.     {
  151.         out << "obj.m_pName:" << obj.m_pName << "obj.age :" << obj.age << endl;
  152.         return out;
  153.     }
  154. public:
  155.     Teacher()
  156.     {
  157.         age = 33;
  158.         m_pName = new char[1];
  159.         strcpy(m_pName, "");
  160.     }
  162.     Teacher(char *name, int age)
  163.     {
  164.         this->age = age;
  165.         //根据name分配内存大小
  166.         m_pName = new char[strlen(name) + 1];
  167.         strcpy(m_pName, name);
  168.     }
  170.     ~Teacher()
  171.     {
  172.         if (m_pName != NULL)
  173.         {
  174.             delete[] m_pName;
  175.             m_pName = NULL;
  176.             age = 0;
  177.         }
  178.     }
  179.     void printT()
  180.     {
  181.         cout << m_pName << ", " << age << endl;
  182.     }
  183. public:
  184.     //    1）    重写拷贝构造函数
  185.     Teacher(const Teacher &obj)
  186.     {
  187.         m_pName = new char[strlen(obj.m_pName) + 1];
  188.         strcpy(m_pName, obj.m_pName);
  189.     }
  190.     //    2）    重载等号操作符
  191.     //t1=t2=t3
  192.     Teacher& operator = (const Teacher &obj)
  193.     {
  194.         //1 释放旧的内存空间
  195.         if (m_pName != NULL)
  196.         {
  197.             delete[] m_pName;
  198.             m_pName = NULL;
  199.             age = 0;
  200.         }
  201.         //2 根据obj分配内存大小
  202.         m_pName = new char[strlen(obj.m_pName) + 1];
  204.         //3 进行copy
  205.         strcpy(m_pName,obj.m_pName);
  206.         age = obj.age;
  208.         return *this;
  209.     }
  211. public:
  212.     int age;
  213.     //char name[32];
  214.     char *m_pName;
  215. };
  217. void main()
  218. {
  219.     Teacher t1("t1", 31), t2("t2", 32), t3("t3", 33), t4("t4", 34);
  221.     MyVector<Teacher *> tArray(4);
  223.     tArray[0] = &t1;
  224.     tArray[1] = &t2;
  225.     tArray[2] = &t3;
  226.     tArray[3] = &t4;
  228.     for (int i = 0; i<4; i++)
  229.     {
  230.         Teacher *tmp = tArray[i];
  231.         tmp->printT();
  232.     }
  233.     //cout << tArray; 这里打印出来是存储Teacher类型的地址 不知道如何让他直接打印出来
  234.     //感觉这里的Teacher重载<<根本没用上啊
  235.     cout << "hello..." << endl;
  236.     system("pause");
  237.     return;
  238. }
  239. //数组模板类（MyVector）完成对int类型元素的管理
  240. void main01()
  241. {
  242.     MyVector<int> myv1(10);
  244.     for (int i = 0; i < 10; i++)
  245.     {
  246.         myv1[i] = i + 1;
  247.         cout << myv1[i] << " ";
  248.     }
  249.     cout << endl;
  252.     MyVector<int> myv2 = myv1;
  253.     for (int i = 0; i < 10; i++)
  254.     {
  255.         cout << myv2[i] << " ";
  256.     }
  257.     cout << endl;
  258.     cout << myv2 << endl;
  259.     //重载<<
  260.     //ostream& operator << (ostream &out, MyVector<T> &obj)
  263.     cout << "hello..." << endl;
  264.     system("pause");
  265.     return;
  266. }
  267. //数组模板类（MyVector）完成对char类型元素的管理
  268. void main02()
  269. {
  270.     MyVector<char> myv1(10);
  271.     myv1[0] = 'a';
  272.     myv1[1] = 'b';
  273.     myv1[2] = 'c';
  274.     myv1[3] = 'd';
  276.     cout << myv1;
  278.     system("pause");
  279. }
  281. //数组模板类（MyVector）完成对Teacher类型元素的管理
  282. void main03()
  283. {
  284.     Teacher t1("t1", 31), t2("t2", 32), t3("t3", 33), t4("t4", 34);
  286.     MyVector<Teacher> tArray(4);
  288.     tArray[0] = t1;
  289.     tArray[1] = t2;
  290.     tArray[2] = t3;
  291.     tArray[3] = t4;
  293.     for (int i = 0; i<4; i++)
  294.     {
  295.         Teacher tmp = tArray[i];
  296.         tmp.printT();
  297.     }
  298.     //结论1：如果把Teacher放入到MyVector数组中，并且Teacher类的属性含有指针，就是出现//深拷贝和浅拷贝的问题。
  299.     //    结论2：需要Teacher封装的函数有：
  300.     //    1）    重写拷贝构造函数
  301.     //    2）    重载等号操作符
  302.     //    3）    重载左移操作符。
  304.     cout << tArray;
  308.     system("pause");
  309. }
  310. /

发表评论

表情：
评论列表 （有 0 条评论，366人围观）

还没有评论，来说两句吧...

相关阅读

    相关 C++函数模板和类模板

    C++语言全盘继承了C语言的标准库，其中包含非常丰富的系统函数，例如输入/输出函数、数学函数、字符串处理函数和动态内存分配函数等。C++语言另外又增加了一些新的库，我们把C++

    桃扇骨桃扇骨/ 0 赞/ 249 阅读

    相关 C++ 函数模板&类模板详解

    在 C++ 中，模板分为函数模板和类模板两种。函数模板是用于生成函数的，类模板则是用于生成类的。 函数模板&模板函数     类模板&模板类  必须区分概念 函数模板是模板

    以你之姓@以你之姓@/ 0 赞/ 652 阅读