C++函数模板详解
C语言函数库详解(收藏版)
c语言函数库
目录
第一章（C标准库） ............................................................... 错误!未定义书签。
1. <>：诊断............................................................................. 错误!未定义书签。
2. <>：字符类别测试 ............................................................ 错误!未定义书签。
3. <>：错误处理..................................................................... 错误!未定义书签。
4. <>：整型常量..................................................................... 错误!未定义书签。
5. <>：地域环境..................................................................... 错误!未定义书签。
6. <>：数学函数..................................................................... 错误!未定义书签。
7. <>：非局部跳转................................................................. 错误!未定义书签。
C++Template基础篇（一）：函数模板详解
C++Template基础篇（⼀）：函数模板详解
Template所代表的泛型编程是C++语⾔中的重要的组成部分，我将通过⼏篇blog对这半年以来的学习做⼀个系统的总结，本⽂是基础篇的第⼀部分。
为什么要有泛型编程
C++是⼀门强类型语⾔，所以⽆法做到像动态语⾔（python javascript）那样⼦，编写⼀段通⽤的逻辑，可以把任意类型的变量传进去处理。泛型编程弥补了这个缺点，通过把通⽤逻辑设计为模板，摆脱了类型的限制，提供了继承机制以外的另⼀种抽象机制，极⼤地提升了代码的可重⽤性。
注意：模板定义本⾝不参与编译，⽽是编译器根据模板的⽤户使⽤模板时提供的类型参数⽣成代码，再进⾏编译，这⼀过程被称为模板实例化。⽤户提供不同的类型参数，就会实例化出不同的代码。
函数模板定义
把处理不同类型的公共逻辑抽象成函数，就得到了函数模板。
函数模板可以声明为inline或者constexpr的，将它们放在template之后，返回值之前即可。
普通函数模板
下⾯定义了⼀个名叫compare的函数模板，⽀持多种类型的通⽤⽐较逻辑。
template<typename T>
int compare(const T& left, const T& right) {
if (left < right) {
return -1;
}
if (right < left) {
return 1;
}
return 0;
}
compare<int>(1, 2); //使⽤模板函数
成员函数模板
不仅普通函数可以定义为模板，类的成员函数也可以定义为模板。
c语言常用函数大全及详解
C语言常用函数包括：
1.printf函数：用于在控制台输出数据。
2.scanf函数：用于从控制台读取用户输入的数据。
3.strlen函数：用于计算字符串的长度。
4.strcmp函数：用于比较两个字符串的大小。
5.strcpy函数：用于将一个字符串复制到另一个字符串中。
6.strcat函数：用于将一个字符串连接到另一个字符串的末尾。
7.strchr函数：用于查找字符串中指定字符的位置。
8.strstr函数：用于查找字符串中指定子串的位置。
9.atoi函数：用于将字符串转换为整数。
10.atof函数：用于将字符串转换为浮点数。
11.malloc函数：用于动态分配内存空间。
12.free函数：用于释放动态分配的内存空间。
13.memcpy函数：用于将一段内存区域的数据复制到另一段内存区域。
14.memset函数：用于将一段内存区域的数据设置为指定的值。
15.abs函数：用于计算整数的绝对值。
16.rand函数：用于生成随机数。
17.srand函数：用于设置随机数生成器的种子。
18.time函数：用于获取当前的系统时间。
19.localtime函数：用于将时间戳转换为本地时间。
20.strtol函数：用于将字符串转换为长整型数。
21.strtod函数：用于将字符串转换为双精度浮点数。
22.fprintf函数：用于将数据格式化输出到文件中。
23.fscanf函数：用于从文件中读取格式化的数据。
24.fgets函数：用于从文件中读取一行数据。
25.fputs函数：用于将数据写入文件中。
26.fopen函数：用于打开文件。
c语言常用函数大全超详细
c语言常用函数大全超详细
C语言常用函数大全：A Comprehensive Guide in Chinese
C语言是一种非常流行且广泛应用的编程语言，其提供了许多内置函数来处理各种任务。在本
文中，我们将详细介绍一些C语言常用的函数，以帮助初学者和有经验的程序员更好地理解和应用这些函数。
1. printf()函数：该函数用于输出文本到屏幕或文件。使用格式化字符串可以实现不同类型的输出，如整数、浮点数和字符串。
2. scanf()函数：该函数用于从用户输入中读取数据，并将其保存到变量中。和printf()函数一样，scanf()函数也使用格式化字符串来指定输入的数据类型。
3. strlen()函数：该函数用于计算字符串的长度。它返回一个无符号整数，表示字符串中字符的
数量，不包括空结束符。
4. strcpy()函数：该函数用于将一个字符串复制到另一个字符串。它将源字符串中的字符复制到目标字符串中，并在目标字符串的末尾添加空结束符。
5. strcat()函数：该函数用于将一个字符串连接到另一个字符串的末尾。它将源字符串中的字符
连接到目标字符串的末尾，并确保目标字符串以空结束符结尾。
6. atoi()函数：该函数将一个字符串转换为整数并返回结果。
7. atof()函数：该函数将一个字符串转换为浮点数并返回结果。
8. srand()函数：该函数用于初始化随机数生成器。通过提供一个种子值，可以生成伪随机数序列。
9. rand()函数：该函数生成一个伪随机数。在调用srand()函数之后，可以使用rand()函数来获
C++模板详解（一）
C++模板详解（⼀）
C++模板
模板是C++⽀持参数化多态的⼯具，使⽤模板可以使⽤户为类或者函数声明⼀种⼀般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。
模板是⼀种对类型进⾏参数化的⼯具；
通常有两种形式：函数模板和类模板；
函数模板针对仅参数类型不同的函数；
类模板针对仅数据成员和成员函数类型不同的类。
使⽤模板的⽬的就是能够让程序员编写与类型⽆关的代码。⽐如编写了⼀个交换两个整型int 类型的swap函数，这个函数就只能实现int 型，对double，字符这些类型⽆法实现，要实现这些类型的交换就要重新编写另⼀个swap函数。使⽤模板的⽬的就是要让这程序的实现与类型⽆关，⽐如⼀个swap模板函数，即可以实现int 型，⼜可以实现double型的交换。模板可以应⽤于函数和类。下⾯分别介绍。
注意：模板的声明或定义只能在全局，命名空间或类范围内进⾏。即不能在局部范围，函数内进⾏，⽐如不能在main函数中声明或定义⼀个模板。
⼀、函数模板通式
1、函数模板的格式：
template <class形参名，class形参名，......> 返回类型函数名(参数列表)
{
函数体
}
其中template和class是关见字，class可以⽤typename 关见字代替，在这⾥typename 和class没区别，<>括号中的参数叫模板形参，模板形参和函数形参很相像，模板形参不能为空。⼀但声明了模板函数就可以⽤模板函数的形参名声明类中的成员变量和成员函数，即可以在该函数中使⽤内置类型的地⽅都可以使⽤模板形参名。模板形参需要调⽤该模板函数时提供的模板实参来初始化模板形参，⼀旦编译器确定了实际的模板实参类型就称他实例化了函数模板的⼀个实例。⽐如swap的模板函数形式为
c程序函数的格式
c程序函数的格式
在C语言中，函数的基本格式如下：
返回类型函数名(参数类型1 参数名1, 参数类型2 参数名2, ...) { // 函数体
// 在这里实现函数的具体功能
// 返回语句
return 返回值;
}
这里是一个简单的例子：
#include <stdio.h>
// 函数声明
int add(int a, int b);
int main() {
// 函数调用
int result = add(3, 5);
// 打印结果
printf("Sum: %d\n", result);
return 0;
}
// 函数定义
int add(int a, int b) {
// 函数体
int sum = a + b;
// 返回语句
return sum;
}
在上面的例子中：
•int是返回类型，表示该函数返回一个整数。
•add是函数名。
•(int a, int b)是参数列表，表示该函数接受两个整数类型的参数。
•{ ... }之间的部分是函数体，包含了函数的具体实现。
•return sum;是返回语句，表示函数的返回值是变量sum的值。
这只是一个简单的例子，实际中函数可能包含更多的参数和更复杂的逻辑。函数的声明通常会放在程序的开头，以便在使用函数之前告诉编译器有这个函数存在。函数的定义则包含函数的具体实现。
C语言函数篇讲解解析
4.形参：只能是变量，每个形参前要有类型名；当定义的 函数没有形参时叫作“无参函数” ； 形式：类型标识符 函数名（） { 声明部分 语句 } 5.函数体：当声明部分和语句都没有时,称为“空函数”, 空函数没有任何实际作用； 形式：类型说明符 函数名（ ） { } 例如：dummy( ) { }
例如:
例
三 对被调用函数的声明
函数声明的一般形式: 函数类型 函数名(参数类型1，参数类型2, …）;
例: 说明:
int max(int, int);
或 int max(int x, int y); 1.使用用户定义函数时，要对函数进行声明。
2.如果函数的返回值类型为int，可以不用声明。
main( ) 例： {float add(float x, float y); /*对被调函数声明*/ float a,b,c; scanf(“%f,%f”,&a,&b); c=add(a,b); /*函数调用(函数表达式)*/ printf(“Sum is %f”,c); } float add(float x, float y) {float z; z=x+y; return(z); }
四 程序举例 例1:用函数调用的方法求两个数的和。
float add(float x, float y) { return (x+y); } main() { float a,b,sum; scanf(“%f%f”,&a,&b); sum=add(a,b); printf(“sum=%f”,sum); }
C++程序设计04737 第9章 函数模板与类模板
2)类型说明符标识符，指明函数模板中可以接收一个由“类型说明符”所规定类型的常量作 为参数。
那样只将声明放在头文件中。 3)函数指针也只能指向模板的实例，而不能指向模板本身。 编译器由函数模板自动生成模板函数时，会用具体的类型名对模板中所有的类型参数进行
替换，其他部分则原封不动地保留。同一个类型参数只能替换为同一种类型。编译器在编 译到调用函数模板的语句时，会根据实参类型判断该如何替换模板中的类型参数。 在某些编译器中，模板只有在被实例化时，编译器才会检查其语法正确性。如果程序中却 没有用到，那么编译器不会报告这个模板中的语法错误。 编译器研对模板进行实例化时，还可以使用显式方式，明确指明要把类型参数实例化为哪 种类型。 模板名<实际类型参数1，实际类型参数2，…>
7. { if(left < right) return -1;
8.
else if(right < left) return 1;
9.
else return 0;}
10. template <class T> //类类型T
11. void Swap(T &x,T &y)//可以交换类对象
C++模版函数详解
C++模版函数详解
C++中的模版总体可以分为两⼤类：模版函数、模版类。本篇⽂章先写模版函数，接下来会介绍模版类。
定义：模版函数是通⽤的函数描述，也就是说它们使⽤通⽤类型来定义，其中的通⽤类型可⽤具体类型替换。
代码实例：
#include <iostream>
//模版类的声明
template<typename T>
void Swap(T& a,T& b);
int main()
{
int i = 10;
int j = 20;
std::cout<<"i=" << i << "," << "j=" <<j;
Swap(i,j);//⽣成 void Swap(int &,int&);
std::cout<<"i=" << i << "," << "j=" <<j;
double x = 11.5;
double y = 19.5;
std::cout<<"x=" << x << "," << "y=" <<y;
Swap(x,y);//编译器⽣成 void Swap(double &,double&);
std::cout<<"x=" << x << "," << "y=" <<y;
return 0;
}
//模版类的定义
template<typename T>
C语言函数ppt课件
f2()
…… ……
f3()
4
5.2 函数基本用法
5.2.1 函数的定义 任何函数定义都是由函数头和函数体两部分组成。
一般形式如下： 函数类型 函数名([形参列表]) { 函数体 }
函数类型可以是各种基本数据类型、指针类型、 结构体类型、void（指定函数不返回值）等。
函数名必须是合法的标识符。
int i, j, k, t;
for(i=0;i<n-1;i++) {
if (i==m) break;
k=i;
for(j=i+1;j<n;j++)
if (a[k]>a[j]) k=j;
if (k!=i) {
t=a[k]; a[k]=a[i]; a[i]=t;
}
}
}
24
//输出n个数据，每个数据之间一个空格 void prt(int a[], int n) {
例7：输入n个数据，利用选择排序进行编程，输出第k 轮排序后的数列状况。 选择排序的思想、方法在前面的章节中已经讨论过，这 里我们把选择排序写成函数的形式。
23
#include <stdio.h>
#define N 100
//n个数，进行m趟排序
void selectSort(int a[], int n, int m) {
C语言函数讲解
7.4 函数的调用
2、对被调函数的声明和函数原型
C语言的函数调用遵循: 先定义，后引用的原则；如果对 某函数的调用出现在该函数定义之前，必须用说明语句 对函数进行声明；
7.4 函数的调用
1、函数的声明
函数声明有两种方式：
函数类型 函数名( 参数类型1, 参数类型2,…, ); 函数类型 函数名(参数类型1 参数1，参数类型2 参数2,…, )；
数组元素作函数实参与用变量作实参一样，是单向传递。 例：输出大于0的数；
void p (int y) { if (y>0) printf(“%d “, y); } main() { int k, x[6] ={1, -2, 0, 3, -4, 5}; for (k=0; k<6; k++) p( x[k] ); }
7.7 数组作为函数参数
7.6 函数的递归调用
所以公式为： age(n) = 10 age(n-1) +2 (n=1) (n>1)
函数定义为： int age (int n) { if ( n==1) return(10); else return( age(n-1) +2); }
7.7 数组作为函数参数
1、数组元素作函数实参
在递归程序设计中解决两个问题： 1） 递归计算公式 2） 递归结束条件 例：有5个人坐在一起，问第5个人多少岁？他说比第4个人大2岁。
C语言中实现模板函数
C语言中实现模板函数
在C语言中，没有内置的模板函数的概念，但是可以使用宏定义来实现类似于模板函数的功能。宏定义能够根据传入的参数自动生成相关的代码，以实现代码的复用和泛化。下面将详细介绍如何使用宏定义来实现模板函数。
C语言中的宏定义使用`#define`关键字，可以用于定义常量、函数和代码块。在这里，我们将使用宏定义来实现一个模板函数，以便根据参数类型自动生成相应的代码。下面是实现一个模板函数的步骤：
1. 定义宏函数：我们可以使用宏定义来创建一个通用的函数，其中参数类型用宏参数来表示。例如，我们可以定义一个通用的`max`函数来返回两个参数中的较大值：
```c
#define MAX(a, b) (a > b ? a : b)
```
在这个例子中，`MAX`是宏函数的名称，`a`和`b`是函数的参数，
`(a>b?a:b)`是返回值。调用`MAX`函数时，编译器会自动将函数调用替换为相应的代码。
2.使用宏函数：我们可以在代码中使用`MAX`宏函数来代替原始的函数调用。例如，我们可以调用`MAX`函数来比较两个整数的最大值：```c
int a = 10;
int b = 20;
int max_value = MAX(a, b);
```
在这个例子中，`max_value`将被赋值为`20`，因为`b`的值大于`a`的值。
3.使用宏函数的限制：使用宏函数的一个重要限制是，它只能用于生成表达式，而不能用于定义局部变量或执行复杂的逻辑操作。因此，使用宏函数时应该注意避免出现副作用或不符合预期的行为。
c语言常见函数模板
c语言常见函数模板
获得两个数中较大的数
int getMax(int a,int b)
{
return(a>b?a:b);
}
获得两个数中较小的数
int getMin(int a,int b)
{
return(a<b?a:b);
}
判断一个年份是不是闰年
int isLeap(int year)
{
if(year%400==0||year%100!=0&&year%4==0) return 1;
return 0;
}
交换两个数的位置(需要两个数的地址做实参来调用函数) 方法一:利用中间变量
void changeLocal(int *a,int *b)
{
int t;
t=*a;
*a=*b;
*b=t;
}
方法二:利用加减法
void changeLocal(int *a,int *b) {
*a=*a+*b;
*b=*a-*b;
*a=*a-*b;
}
方法三:利用位运算
void changeLocal(int *a,int *b) {
*a=*a^*b;
*b=*a^*b;
*a=*a^*b;
}
判断一个数是不是素数
int isPrime(int n)
{
int i;
for(i=2;i<=n/2;i++)
if(n%i==0)
return 0;
return 1;
}
判断一个数是不是水仙花数
int judgeNumber(int n)
{
int a,b,c;
a=n%10;
b=n/10%10;
c=n/100;
if(a*a*a+b*b*b+c*c*c==n)
return 1;
return 0;
}
初始化菲波那契数列的n项(n<一定范围，否则超int型数据范围) void fibonacciSequence(int a[],int n)
c语言函数的一般结构形式
c语言函数的一般结构形式
C语言函数的一般结构形式
C语言函数是指一组可执行的代码块，用于完成特定的任务。在C 语言中，函数通常由函数名、参数列表、返回值类型、函数体和局部变量组成。下面将详细介绍C语言函数的一般结构形式。
1. 函数名
函数名是函数的标识符，用于唯一识别函数。函数名通常由字母、数字和下划线组成，且必须以字母或下划线开头。函数名的命名应该具有描述性，能够清晰地表达函数的作用。
2. 参数列表
参数列表是函数的输入，用于接收外部数据。参数列表由多个参数组成，每个参数由参数类型和参数名组成。参数类型用于指定参数的数据类型，参数名用于标识参数，以便在函数体中使用。
3. 返回值类型
返回值类型是函数的输出，用于向调用者返回一个值。返回值类型可以是任何C语言数据类型，例如整型、浮点型、字符型等。如果函数没有返回值，返回值类型应该为void。
4. 函数体
函数体是函数的核心部分，用于完成特定的任务。函数体由多条语句组成，每条语句用于执行具体的操作。函数体中可以定义局部变量，局部变量只能在函数体内部访问。
5. 局部变量
局部变量是指在函数体内部定义的变量，只能在函数体中访问。局部变量的作用域仅限于函数体内部，当函数执行完毕后，局部变量将被销毁。
下面是一个简单的C语言函数示例：
```c
int add(int a, int b) {
int sum = a + b;
return sum;
}
```
在上面的示例中，函数名为add，参数列表为a和b，返回值类型为int，函数体中定义了一个局部变量sum，用于存储a和b的和，最后通过return语句将sum返回。
c++ 模板调用函数
C++ 模板可以用于定义通用的函数和类，可以接收不同类型的参数，并根据参数类型
生成对应的代码。调用模板函数可以像调用普通函数一样使用，只需在函数名后加上
尖括号并指定参数类型即可。
以下是一个简单的 C++ 模板函数示例，用于计算两个数的和：
```c++
template<typename T>
T Add(T a, T b)
{
return a + b;
}
```
以上代码定义了一个名为 `Add` 的模板函数，接受两个类型相同的参数，并返回它们
的和。其中，`typename T` 是模板参数类型，可以是任何数据类型，例如 `int`、
`double`、`float` 等。
要调用这个模板函数，可以使用以下语句：
```c++
int result = Add<int>(2, 3);
```
以上语句将调用`Add` 函数，并将模板参数类型指定为`int`。函数将计算2 和3 的和，并返回结果 5，存储在 `result` 变量中。
需要注意的是，在实际编程中，通常会将模板函数的声明和实现分别写在不同的文件中，以便更好地组织代码和提高可重用性。另外，C++ 还支持模板类和模板成员函数
等高级特性，可以进一步扩展模板的功能和应用场景。
《C 程序设计实例与操作》(於实 孟程 刘锋)759-3课件 第13章
综合实例2 选择不同的排序方法排序
//实例13-2.cpp
#include <iostream>
using namespace std;
template <class T>
//定义类模板
class Nsort
{ public:
void Bubble2Sort(T*,int);
//成员函数，双向冒泡排序
测试数据与运行结果：
请输入需要排序的整型数据的个数：6↙ 请依次输入6个整型数据: 34 6 28 69 3 24↙ 依次输出6个排好序的整型数据: p[0]=3 p[1]=6 p[2]=24 p[3]=28 p[4]=34 p[5]=69 请输入需要排序的实型数据的个数：8↙ 请依次输入8个实型数据: 25.5 72.8 9.2 51.4 4.3 63.2 48.2 2.8↙ 依次输出8个排好序的实型数据: d[0]=2.8 d[1]=4.3 d[2]=9.2 d[3]=25.5 d[4]=48.2 d[5]=51.4 d[6]=63.2 d[7]=72.8 请输入需要排序的字符型数据的个数：10↙ 请依次输入10个字符型数据: goodboyhnr↙ 依次输出10个排好序的字符型数据: c[0]=b c[1]=d c[2]=g c[3]=h c[4]=n c[5]=o c[6]=o c[7]=o c[8]=r c[9]=y
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C++函数模板详解
经常有碰到函数模块的应用,很多书上也只是略有小讲一下,今天又狂碰到函数模块,无奈特地找来C++编程经典<
C++函数模块基础知识:
一. 问题:
强类型语言要求我们为所有希望比较的类型都实现一个实例
int min( int a, int b ) {
return a < b ? a : b;
}
double min( double a, double b ) {
return a < b ? a : b;
}
有一种方法可替代为每个min()实例都显式定义一个函数的方法这种方法很有吸引力但是也很危险.那就是用预处理器的宏扩展设施例如 :#define min(a,b) ((a) < (b) ? (a) : (b))
在复杂调用的情况下,它的行为是不可预期的,这是因为它的两个参数值都被计算两次.一次是在a 和b 的测试中另一次是在宏的返回值被计算期间.
#include
#define min(a,b) ((a) < (b) ? (a) : (b))
const int size = 10;
int ia[size];
int main() {
int elem_cnt = 0;
int *p = &ia[0];
// 计数数组元素的个数
while ( min(p++,&ia[size]) != &ia[size] )
++elem_cnt;
cout << "elem_cnt : " << elem_cnt
<< "\texpecting: " << size << endl;
return 0;
}
执行该程序的结果是下面不正确的计算结果: elem_cnt : 5 expecting: 10
min()的宏扩展在这种情况下会失败因为应用在指针实参p 上的后置递增操作随每次扩展而被应用了两次
二 . 解决办法:
函数模板提供了一种机制通过它我们可以保留函数定义和函数调用的语义在一个程序位置上封装了一段代码确保在函数调用之前实参只被计算一次.
函数模板提供一个种用来自动生成各种类型函数实例的算法程序员对于函数接口参数和返回类型中的全部或者部分类型进行参数化(parameterize)而函数体保持不变.
下面是min()的函数模板定义
template
Type min( Type a, Type b ) {
return a < b ? a : b;
}
三. 具体操作
关键字template 总是放在模板的定义与声明的最前面关键字后面是用逗号分隔的模板参数表（template parameter list）它用尖括号<> 一个小于号和一个大于号括起来该列表是模板参数表不能为空模板参数可以是一个模板类型参数（template typeparameter）它代表了一种类型也可以是一个模板非类型参数（template nontype parameter）它代表了一个常量表达式模板类型参数由关键字class
或typename后加一个标识符构成在函数的模板参数表中这两个关键字的意义相同。
模板非类型参数由一个普通的参数声明构成模板非类型参数表示该参数名代表了一个潜在的值而该值代表了模板定义中的一个常量例如size 是一个模板非类型参数它代表arr 指向的数组的长度
template
Type min( Type (&arr) [size] );
当函数模板min()被实例化时size 的值会被一个编译时刻已知的常量值代替。函数定义或声明跟在模板参数表后除了模板参数是类型指示符或常量值外函数模板的定义看起来与非模板函数的定义相同
template
Type min( const Type (&r_array)[size] )
{
/* 找到数组中元素最小值的参数化函数 */
Type min_val = r_array[0];
for ( int i = 1; i < size; ++i )
if ( r_array[i] < min_val )
min_val = r_array[i];
return min_val;
}
在程序的运行过程中Type 会被各种内置类型和用户定义的类型所代替而size 会被各种常量值所取代这些常量值是由实际使用的min()决定的记住一个函数的两种用法是调用它和取它的地址
当一个名字被声明为模板参数之后它就可以被使用了一直到模板声明或定义结束为止模板类型参数被用作一个类型指示符可以出现在模板定义的余下部分它的使用方式与内置或用户定义的类型完全一样比如用来声明变量和强制类型转换模扳非类型参数被用作一个常量值可以出现在模板定义的余下部分它可以用在要求常量的地方或许是在数组声明中指定数组的大小或作为枚举常量的初始值
四．几点注意
① 如果在全局域中声明了与模板参数同名的对象函数或类型则该全局名将被隐藏在下面的例子中tmp 的类型不是double 是模板参数Type
typedef double Type;
template
Type min( Type a, Type b )
{
// tmp 类型为模板参数 Type
// 不是全局 typedef
Type tmp = a < b ? a : b;
return tmp;
}
② 在函数模板定义中声明的对象或类型不能与模板参数同名
template
Type min( Type a, Type b )
{
// 错误: 重新声明模板参数 Type
typedef double Type;
Type tmp = a < b ? a : b;
return tmp;
}
③ 模板类型参数名可以被用来指定函数模板的返回位
// ok: T1 表示 min() 的返回类型
// T2 和 T3 表示参数类型
template
T1 min( T2, T3 );