c,,模板类实例化
c++模板编译过程
c++模板编译过程C++模板编译过程是指在编译C++程序时，对使用了模板的代码进行编译的过程。
下面从预处理、编译和链接三个阶段介绍C++模板的编译过程。
1. 预处理预处理是C++程序的第一个阶段，其主要功能是对源代码进行宏展开、条件编译、头文件包含等处理，并生成一份预处理文件供后面的编译器使用。
在预处理C++模板程序时，编译器会对模板代码进行解析，并创建对应实例化代码的预处理器全局存储。
例如，以下代码中的模板类定义将在预处理阶段中被解析：```cpptemplate<typename T>class myClass{public:T add(T a, T b){return a + b;}};```编译器在解析模板代码时并不会生成实例化代码，而是在程序编译之后进行生成。
2. 编译```cppmyClass<int> obj1;myClass<double> obj2;```编译器会根据实例化代码的类型创建对应的类或函数实例，并将其作为独立的函数或类添加到目标文件中。
3. 链接链接是C++程序的最后一个阶段，其主要功能是将多个目标文件链接在一起，并生成可执行文件或库文件。
在链接阶段中，编译器会根据函数或类的定义和声明，将其在多个目标文件中的实例化代码进行匹配，最终生成可执行文件或库文件。
```cpp#include "myClass.h"在链接阶段中，编译器会匹配myClass类的定义和声明，然后将在编译阶段中生成的实例化代码链接起来，最终生成可执行文件。
总结C++模板编译过程分为预处理、编译和链接三个阶段。
在预处理阶段中，编译器会对模板代码进行解析，并创建对应实例化代码的预处理器全局存储；在编译阶段中，编译器会为模板类和模板函数创建实例化代码并将其加入目标文件中；在链接阶段中，编译器会将多个目标文件中的实例化代码进行匹配，最终生成可执行文件或库文件。
类模板工作原理
类模板工作原理
类模板（class template）是C++中的一种特殊类型，用于实现
通用的数据结构或算法。
类模板工作的原理可以简要描述如下：
1. 定义模板：使用关键字`template`开头，后面跟着模板参数
列表和类定义。
模板参数列表可以包含类型参数、非类型参数和模板模板参数。
2. 实例化模板：当使用模板创建对象时，编译器会根据实际的类型参数替换模板中的类型参数，生成具体的类定义。
这个过程称为模板的实例化。
3. 生成类定义：实例化模板后，编译器会基于模板定义生成特定类型的类定义。
这个类定义会包含模板定义中的成员函数和成员变量，但类型参数会被实际的类型替代。
4. 编译生成的代码：编译器根据生成的类定义，将代码编译成可执行的机器码。
生成的代码中的类型相关操作会被转换为实际类型的操作。
5. 运行程序：编译生成的代码会被加载到内存中，并被计算机执行。
在运行时，类模板的对象会根据实际的类型参数进行操作，而非模板定义时的类型参数。
需要注意的是，类模板的实际代码是在编译器进行模板实例化时生成的，而不是在运行时动态生成的。
这意味着每种实际类
型的类定义是独立的，不同实例的对象可以在相同的程序中同时存在，并且彼此之间是完全隔离的。
c++ template 实现原理
c++ template 实现原理C++模板是一种编程工具，它可以在编译时进行泛型编程。
它允许我们在代码中定义一种通用的类型或算法，使其适用于多种不同的类型，而无需为每种新类型编写新的代码。
C++模板的实现原理可以分为两个阶段：实例化和实例化后的代码生成。
在实例化阶段，编译器扫描模板代码，找到模板声明，并根据模板被调用时的参数类型，生成模板实例。
例如，假设我们有一个模板函数add，并在代码中调用该函数add<int>(2, 3)。
在实例化阶段，编译器会根据模板函数add的定义，生成一个具有int类型参数的实例。
这个过程称为模板实例化。
在实例化后的代码生成阶段，编译器会根据生成的模板实例，生成对应的函数或类代码。
这些代码与普通的函数或类定义具有相同的形式，只是参数类型被模板参数替代。
生成的代码会被链接器处理，以生成最终的可执行文件。
C++模板的实现原理依赖于编译器的支持。
在编译器实现中，有两种常见的模板实现方法：编译时生成和二次编译。
编译时生成是指编译器在实例化阶段直接将模板代码转换为对应的实例代码。
在这种实现方法中，编译器会在模板被调用时生成对应的实例代码，并将其插入到编译单元中。
这种方法的优点是生成的代码效率高，缺点是编译时间可能会增长，特别是当模板被多次实例化时。
二次编译是指编译器在生成模板实例后，使用实例化后的代码进行二次编译。
在这种实现方法中，编译器会将模板实例生成为中间表示形式，然后在实例化完成后，将中间表示形式作为输入，生成对应的机器代码。
这种方法的优点是编译时间快，缺点是生成的代码可能会比编译时生成的代码效率低一些。
无论是编译时生成还是二次编译，模板实例化都是通过对模板参数类型进行替换来完成的。
编译器会根据调用模板时的参数类型，在模板代码中进行相应的替换。
这个过程称为模板参数推导。
模板参数推导是通过编译器进行类型推导来实现的。
编译器会根据模板代码和调用代码中的参数类型，推导出模板参数的具体类型。
如何导出标准模板库（STL）类的实例化和包含STL类对象数据成员的类
如何导出标准模板库（STL）类的实例化和包含STL类对象数据成员的类概要本⽂讨论如何实现下⾯任务：导出标准模板库（STL）类的实例化。
导出包含STL类对象数据成员的类。
注意，您⽆法导出通⽤的模板，模板必须实例化才能导出。
也就是说，必须提供所有的模板参数，并且在实例化时，模板的参数必须是完全定义的类型。
例如stack<int>实例化STL堆栈类，实例化时强制⽣成类stack<int>的所有成员。
还要注意，⼀些STL容器（map、set、queue、list、deque）⽆法导出。
更多信息从VC++ 5.0开始，可以强制对模板类进⾏实例化并导出实例化类。
导出实例化模板类，可使⽤以下语法：导出STL类1. 在.dll和.exe⽂件中，必须链接到相同版本的C运⾏时库dll。
两个都链接msvcrt.lib(Release版本)或都链接到msvcrtd.lib(Debug版本)。
2. 在dll中，在模板的实例化声明中使⽤__declspec修饰符，以便从dll中导出STL类的实例化。
3. 在exe中，需提供使⽤extern和__declspec修饰的模板实例化声明，以便从dll中导⼊类。
这会导致警告 C4231 "nonstandard extension used :'extern' before template explicit instantiation." 。
您可以忽略此警告。
导出包含STL类对象数据成员的类1. 在.dll和.exe⽂件中，必须链接到相同版本的C运⾏时库dll。
两个都链接msvcrt.lib(Release版本)或都链接到msvcrtd.lib(Debug版本)。
2. 在dll中，在模板的实例化声明中使⽤__declspec修饰符，以便从dll中导出STL类的实例化。
注意：不能跳过上⼀步，⽤于创建数据成员的STL类必须导出其实例化。
c创建对象的方法
c创建对象的方法在面向对象的编程中，创建对象是一项基础且关键的操作。
在各种编程语言中，我们可以使用不同的方法来创建对象，包括实例化类、使用工厂方法、使用构造函数等等。
本文将为您介绍几种常见的创建对象的方法。
1. 实例化类在大多数面向对象的编程语言中，创建对象最常见的方法就是实例化类。
类是一种定义对象属性和行为的模板，而实例化则是根据类创建一个具体的对象实例。
以Java语言为例，我们需要先定义一个类，然后使用关键字“new”来实例化这个类。
以下是一个简单的示例：```public class Person {private String name;private int age;public Person(String name, int age) { = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}}// 创建Person对象Person person = new Person("张三", 25);```2. 使用工厂方法工厂方法是一种创建对象的设计模式，它通过定义一个工厂类，将对象的创建逻辑封装在工厂类中，使得客户端代码与具体类的实例化过程解耦。
下面是一个简单的例子，在Python语言中使用工厂方法创建对象：```class Animal:def say_hello(self):passclass Dog(Animal):def say_hello(self):print("汪汪汪！")class Cat(Animal):def say_hello(self):print("喵喵喵！")class AnimalFactory:def create_animal(self, animal_type):if animal_type == "dog":return Dog()elif animal_type == "cat":return Cat()# 使用工厂方法创建对象factory = AnimalFactory()dog = factory.create_animal("dog")cat = factory.create_animal("cat")```3. 使用构造函数构造函数是一种在对象创建过程中被调用的特殊函数，用于初始化对象的属性。
模板类的用法
模板类的用法模板类是C++中非常重要的一种特性，它可以通过参数化类型实现通用的数据结构和算法，从而提高代码的复用性和灵活性。
在本文中，我们将深入探讨模板类的使用方法，包括模板类的定义、实现以及常见的应用场景。
一、模板类的定义在C++中，模板类的定义使用关键字template和typename（或class）来声明模板参数，并且在类名后面使用尖括号<>来指定模板参数。
下面是一个简单的模板类的定义示例：```cpptemplate <typename T>class Stack {public:Stack();void push(const T& val);T pop();bool isEmpty();private:std::vector<T> elements;};```在上面的例子中，我们定义了一个模板类Stack，其中T是模板参数，它表示栈中存储的元素的类型。
使用模板类可以使我们在不同的上下文中使用不同类型的数据，而不需要重新实现整个类的逻辑。
二、模板类的实现模板类的实现通常需要包含在头文件中，因为编译器需要在使用模板类的地方进行实例化以生成具体的代码。
我们可以将模板类的声明和实现放在同一个头文件中，或者将模板类的声明放在头文件中，实现放在独立的源文件中。
下面是一个模板类的实现示例：```cpptemplate <typename T>Stack<T>::Stack() {}template <typename T>void Stack<T>::push(const T& val) {elements.push_back(val);}template <typename T>T Stack<T>::pop() {if (isEmpty()) {throw std::runtime_error("Stack is empty");}T val = elements.back();elements.pop_back();return val;}template <typename T>bool Stack<T>::isEmpty() {return elements.empty();}```上面的代码展示了一个简单的栈类的实现，其中所有成员函数都使用了模板参数T。
C++模板之函数模板实例化和具体化
C++模板之函数模板实例化和具体化模板声明 template<typename/class T>, typename⽐class最近后添加到C++标准。
常规模板，具体化模板，⾮模板函数的优先调⽤顺序。
⾮模板函数（普通函数）> 具体化模板函数 > 常规模板显⽰具体化：具体化表⽰为某⼀特定的类型重写函数模板，声明的含义是使⽤独⽴的，专门的函数定义显⽰地为特定类型⽣成函数定义。
为什么要有显⽰具体化？处理模板函数所不能处理的特殊情况。
显式具体化显式具体化也是基于函数模板的，只不过在函数模板的基础上，添加⼀个专门针对特定类型的、实现⽅式不同的具体化函数。
显⽰具体化声明在关键字template后包含<>.如：1. template<> void swap<job>(job &j1, job &j2);vs2013不⽀持：1. void swap(Any &a, Any &b);2.3. struct job4. {5. char name[40];6. double salary;7. int floor;8. };9.10. template<> void swap<job>(job &j1, job &j2);11.12. void Show(job &j);13.14. int main(){15. using namespace std;16.17. template void swap<job>(job &, job &);18.19. int i = 10, j = 20;20.21. swap(i, j);22.23.24. return 0;25. }26.27.28. template<typename Any>29. void swap(Any &a, Any &b){30. Any temp;31. temp = a;32. a = b;33. b = temp;34. }35.36. template<> void swap<job>(job &j1, job &j2){37. double temp_sal;38. temp_sal = j1.salary;39. j1.salary = j2.salary;40. j2.salary = temp_sal;41. }隐式实例化在发⽣函数模板的调⽤时，不显⽰给出模板参数⽽经过参数推演，称之为函数模板的隐式模板实参调⽤（隐式调⽤）。
模板类的用法
模板类（Template Class）是C++中的一种特殊类型的类，它允许你编写通用的类，以处理不同数据类型的数据，而不需要为每种数据类型编写不同的类。
模板类是C++模板的一部分，用于实现通用性和代码重用。
以下是模板类的基本用法和示例：声明模板类要声明一个模板类，你可以使用template关键字，后跟模板参数列表，然后定义类模板的主体。
通常，模板参数表示数据类型或其他模板。
template <typename T>class MyTemplateClass {public:// 类成员和成员函数的定义，可以使用类型TT data;void setData(T val) {data = val;}T getData() {return data;}};在上面的示例中，typename T是模板参数，表示我们可以在模板类中使用的任何数据类型。
实例化模板类要实例化一个模板类，你需要在实例化时提供实际的数据类型，这样编译器才能生成相应的代码。
MyTemplateClass<int> intObj; // 实例化一个存储整数的对象MyTemplateClass<double> doubleObj; // 实例化一个存储双精度浮点数的对象intObj.setData(42);doubleObj.setData(3.14);cout << "Integer data: " << intObj.getData() << endl;cout << "Double data: " << doubleObj.getData() << endl;上述代码创建了两个不同数据类型的模板类对象，一个存储整数，另一个存储双精度浮点数。
通过提供不同的模板参数类型，你可以在同一个模板类中处理多种不同的数据类型。
c++类模板函数模板的问题，模板函数不能是虚函数，虚函数不能是内联
c++类模板函数模板的问题，模板函数不能是虚函数，虚函数不能是内联内联函数不能为虚函数，原因在于虚表机制需要⼀个真正的函数地址，⽽内联函数展开以后，就不是⼀个函数，⽽是⼀段简单的代码，可能有些内联函数会⽆法内联展开，⽽编译成为函数虚函数不能模板化编译器在编译⼀个类的时候，需要确定这个类的虚函数表的⼤⼩。
⼀般来说，如果⼀个类有N个虚函数，它的虚函数表的⼤⼩就是N，如果按字节算的话那么就是4*N。
如果允许⼀个成员模板函数为虚函数的话，因为我们可以为该成员模板函数实例化出很多不同的版本，也就是可以实例化出很多不同版本的虚函数，那么编译器为了确定类的虚函数表的⼤⼩，就必须要知道我们⼀共为该成员模板函数实例化了多少个不同版本的虚函数。
显然编译器需要查找所有的代码⽂件，才能够知道到底有⼏个虚函数，这对于多⽂件的项⽬来说，代价是⾮常⾼的，所以规定成员模板函数不能够为虚函数。
那么编译器在编译Func类的时候，需要查看int mian ⾥⾯的具体调⽤，才知道会产⽣两个虚函数。
⼀个是virtual int Add （const int &a, const int &b）; 另⼀个是 virtual double Add （const double &a, const double &b）。
当项⽬很⼤，⽂件特别多的时候，需要遍历完所有的⽂件才能确定实际会产⽣多少虚函数，所以这样编译的效率会⾮常的低。
因此规定成员模板函数不能够为虚函数最近要修改⼀个模板类的功能，对于特定形式的参数，想要复⽤函数名，进⼊不同的路径，于是就想到了模板函数偏特化举个例⼦#include <iostream>using namespace std;template <class T>class A{public:template <class T2>void Func(T2 t) { cout << t; } //成员函数模板template <>void Func<int>(int t) { cout << t; } //特化int};int main(){A<int> a;a.Func('K'); //成员函数模板Func被实例化a.Func("hello");return0;}此处遇到了⼏个问题1.类模板的模板函数，必须要在类内部定义，不然在外部template都不知道是类的还是函数的如果相对只想对模板类的某个函数偏特化，要⽤以下写法template<typename DataKey, typename Data>class CTemplateReportDataBaseMgr{public:bool print1(Data out_map_report_data,std::vector<DataKey>& in_vt_data_key) ;};template<typename DataKey, typename Data>bool CTemplateReportDataBaseMgr<DataKey, Data>::print1(Data out_map_report_data,std::vector<DataKey>& in_vt_data_key){return true;};template<>bool CTemplateReportDataBaseMgr<class DataKey,int>::print1( //注意这⾥的写法，不能直接像偏特化类⼀样的写法int out_map_report_data,std::vector<DataKey>& in_vt_data_key){return true;};类的模板特化写法template<typename T1,typename T2>class Test{public:Test(T1 i,T2 j):a(i),b(j){cout<<"模板类"<<endl;}private:T1 a;T2 b;};template<> //全特化，由于是全特化，参数都指定了，参数列表故为空。
C++模板之隐式实例化、显示实例化、隐式调用、显示调用和模板特化详解
C++模板之隐式实例化、显⽰实例化、隐式调⽤、显⽰调⽤和模板特化详解模板的实例化指函数模板（类模板）⽣成模板函数（模板类）的过程。
对于函数模板⽽⾔，模板实例化之后，会⽣成⼀个真正的函数。
⽽类模板经过实例化之后，只是完成了类的定义，模板类的成员函数需要到调⽤时才会被初始化。
模板的实例化分为隐式实例化和显⽰实例化。
对函数模板的使⽤⽽⾔，分为两种调⽤⽅式，⼀种是显⽰模板实参调⽤（显⽰调⽤），⼀种是隐式模板实参调⽤（隐式调⽤）。
对于类模板的使⽤⽽⾔，没有隐式模板实参和显式模板实参使⽤的说法，因为类模板的使⽤必须显⽰指明模板实参。
各个概念请勿混淆。
1.隐式实例化1.1模板隐式实例化的定义这是相对于模板显⽰实例化⽽⾔。
在使⽤模板函数和模板类时，不存在指定类型的模板函数和模板类的实体时，由编译器根据指定类型参数隐式⽣成模板函数或者模板类的实体称之为模板的隐式实例化。
1.2函数模板隐式实例化函数模板隐式实例化指的是在发⽣函数调⽤的时候，如果没有发现相匹配的函数存在，编译器就会寻找同名函数模板，如果可以成功进⾏参数类型推演，就对函数模板进⾏实例化。
还有⼀种简介调⽤函数的情况，也可以完成函数模板的实例化。
所谓的简介调⽤是指将函数⼊⼝地址传给⼀个函数指针，通过函数指针完成函数调⽤。
如果传递给函数指针不是⼀个真正的函数，那么编译器就会寻找同名的函数模板进⾏参数推演，进⽽完成函数模板的实例化。
参考如下⽰例。
#include <iostream>using namespace std;template <typename T> void func(T t){cout<<t<<endl;}void invoke(void (*p)(int)){int num=10;p(num);}int main(){invoke(func);}程序成功运⾏并输出10。
1.3类模板隐式实例化类模板隐式实例化指的是在使⽤模板类时才将模板实例化，相对于类模板显⽰实例化⽽⾔的。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
竭诚为您提供优质文档/双击可除c,,模板类实例化篇一：类模板的使用实际上是将类模板实例化成一个具体的()。
a.类b.对一、整体解读试卷紧扣教材和考试说明，从考生熟悉的基础知识入手，多角度、多层次地考查了学生的数学理性思维能力及对数学本质的理解能力，立足基础，先易后难，难易适中，强调应用，不偏不怪，达到了“考基础、考能力、考素质”的目标。
试卷所涉及的知识内容都在考试大纲的范围内，几乎覆盖了高中所学知识的全部重要内容，体现了“重点知识重点考查”的原则。
1．回归教材，注重基础试卷遵循了考查基础知识为主体的原则，尤其是考试说明中的大部分知识点均有涉及，其中应用题与抗战胜利70周年为背景，把爱国主义教育渗透到试题当中，使学生感受到了数学的育才价值，所有这些题目的设计都回归教材和中学教学实际，操作性强。
2．适当设置题目难度与区分度选择题第12题和填空题第16题以及解答题的第21题，都是综合性问题，难度较大，学生不仅要有较强的分析问题和解决问题的能力，以及扎实深厚的数学基本功，而且还要掌握必须的数学思想与方法，否则在有限的时间内，很难完成。
3．布局合理，考查全面，着重数学方法和数学思想的考察在选择题，填空题，解答题和三选一问题中，试卷均对高中数学中的重点内容进行了反复考查。
包括函数，三角函数，数列、立体几何、概率统计、解析几何、导数等几大版块问题。
这些问题都是以知识为载体，立意于能力，让数学思想方法和数学思维方式贯穿于整个试题的解答过程之中。
篇二：c++模板及应用习题答案1.概念填空题1.1c++最重要的特性之一就是代码重用，为了实现代码重用，代码必须具有通用性。
通用代码需要不受数据类型的影响，并且可以自动适应数据类型的变化。
这种程序设计类型称为参数化程序设计。
模板是c++支持参数化程序设计的工具，通过它可以实现参数化多态性性。
1.2函数模板的定义形式是template返回类型函数名(形式参数表){…}。
其中，中参数可以有多个，用逗号分开。
模板参数主要是模板类型参数。
它代表一种类型，由关键字typename或class后加一个标识符构成，标识符代表一个潜在的内置或用户定义的类型参数。
类型参数由可以是任意合法标识符。
c++规定参数名必须在函数定义中至少出现一次。
1.3编译器通过如下匹配规则确定调用那一个函数：首先，寻找最符合函数名和参数类型的一般函数，若找到则调用该函数；否则寻找一个函数模板，将其实例化成一个模板函数，看是否匹配，如果匹配，就调用该模板函数；再则，通过类型转换规则进行参数的匹配。
如果还没有找到匹配的函数则调用错误。
如果有多于一个函数匹配，则调用产生二义性，也将产生错误。
1.4类模板使用户可以为类声明一种模式，使得类中的某些数据成员、某些成员函数的参数、某些成员函数的返回值能取任意类型（包括系统预定类型和用户自定义的类型）。
类是对一组对象的公共性质的抽象，而类模板则是对不同类的数据类型？的抽象，因此类模板是属于更高层次的抽象。
由于类模板需要一种或多种类型参数，所以类模板也常常称为参数化类。
2.简答题2.1简述函数模板生成函数的过程。
2.2简述类模板生成对象的过程。
2.3简述函数模板与模板函数、类模板与模板类的区别。
3.选择题3.1关于函数模板,描述错误的是（a）。
a.函数模板必须由程序员实例化为可执行的函数模板b.函数模板的实例化由编译器实现c.一个类定义中,只要有一个函数模板,则这个类是类模板d.类模板的成员函数都是函数模板,类模板实例化后,成员函数也随之实例化3.2下列的模板说明中,正确的是（d）。
a.templateb.templatec.templated.template3.3函数模板定义如下:templatemax(ta,tb,t}下列选项正确的是（b）。
a.intx,y;charz;b.doublex,y,z;max(x,y,z);max(x,y,z);c.intx,y;floatz;d.floatx;doubley,z；max(x,y,z);max(x,y,z);3.4下列有关模板的描述错误的是(d)。
a．模板把数据类型作为一个设计参数，称为参数化程序设计。
b．使用时，模板参数与函数参数相同，是按位置而不是名称对应的。
c．模板参数表中可以有类型参数和非类型参数。
d．类模板与模板类是同一个概念。
3.5类模板的使用实际上是将类模板实例化成一个（c）。
a．函数b．对象c．类d．抽象类3.6类模板的模板参数（d）。
a．只能作为数据成员的类型b．只可作为成员函数的返回类型c．只可作为成员函数的参数类型d．以上三种均可3.7类模板的实例化（a）。
a．在编译时进行b．属于动态联编c．在运行时进行d．在连接时进行3.8以下类模板定义正确的为（a）。
a．template4．编程题4.1设计一个函数模板，其中包括数据成员ta[n]以及对其进行排序的成员函数sort()，模板参数t可实例化成字符串。
#includeusingnamespacestd;templatevoidsort(t*a,intn){inti,j;tt;for(i=0;ia[j+1])b．templated．templatec．template{t=a[j];a[j]=a[j+1];a[j+1]=t;}}templatevoidprint(t*a,intn){}inti;for(i=0;i intmain(){stringstr[10]={"zhang","li","wang","qian","zhao","wu","xu ","tang","shen","liang"};}4.2设计一个类模板，其中包括数据成员ta[n]以及在其中进行查找数据元素的函数intsearch(t)模板参数t可实例化成字符串。
usingnamespacestd;templateclassa{intsize;t*element;public:a();~a();intsearch(t);voidsetelement(intindex,constt};templatea::a(){size=n>1n:1;element=newt[size];}templatea::~a(){delete[]element;}templateinta::search(tt){inti;}for(i=0;i(str,10);sort(int,8);sort(dou,7);prin t(str,10);print(int,8);print(dou,7);return0;templatevoida::setelement(intindex,constt}intmain(){aintary;//用int实例化，建立模板类对象}adouary;//用double实例化，建立模板类对象inti;for(i=0;i=0)cout=0)cout 4.3设计一个单向链表类模板，节点数据域中数据从小到大排列，并设计插入、删除节点的成员函数。
#includeusingnamespacestd;templateclasslist;templateclassnode{tinfo;//数据域node*link;//指针域public:node();//生成头结点的构造函数node(constt//生成一般结点的构造函数friendclasslist;};templatenode::node(){link=null;}templatenode::node(consttlink=null;//定义链表类templateclasslist{node*head;//链表头指针和尾指针public:list();//构造函数，生成头结点(空链表)~list();//析构函数voidmakeempty();//清空一个链表，只余表头结点node*Find(tdata);//搜索数据域与data相同的结点，返回该结点的地址voidprintlist();//打印链表的数据域voidinsertorder(node*p);//按升序生成链表node*creatnode(tdata);//创建一个结点(孤立结点) node*deletenode(node*p);//删除指定结点};templatelist::list(){head=newnode(-9999);//头结点，最小的数据从小到大插入}templatelist::~list(){makeempty();deletehead;}templatevoidlist::makeempty(){}node*tempp;while(head->link!=null){}tempp=head ->link;head->link=tempp->link;//把头结点后的第一个节点从链中脱离deletetempp;//删除(释放)脱离下来的结。