【c++模板笔记一】模板的介绍及其重载

c++——重载和模板 这通常不是一个好主意。但存在一个主要区别: 模板参数的值是在编译时确定的,以生成函数的不同实例化,因此该参数的值在运行时永远不会传递: 对 in 的两次调用本质上调用了函数的两个版本:一个总是乘以 2,一个总是乘以 3。在此示例中,有两个名为 的函数,但其中一个函数具有两个类型为 的参数,而另一个具有 类型为 的参数。在上面的代码中,声明(用尖括号括起来的模板参数中的泛型类型)允许在函数定义中的任何位置使用,就像任何其他类型一样;因此, result 将是与参数 和 相同类型的变量,并且是函数返回的类型。 阅读详情

2015年2月11日 周三晴

        有一段时间没有更新博客了,这几天在整理前段时间所学的c++知识点就没有更新了。最近开始研究c++的模板的STL,于是开始继续写下自己的一点所得吧。

        模板和STL都是c++中比较实用的东西,能把我们省下很多事情(简化编码)。今天作为模板的第一讲,今天讲的模板其实主要是介绍函数模板。模板还有类模板(我们明天介绍)。

————————————————————分割线——————————————————————

一、为什么需要函数模板?

       在介绍什么是函数模板之前,我们还是先一起想想,到底为什么需要这个东西呢?刚好可以复习前面的知识点。
       现在我们一起来设计程序:用函数来求两个变量中的最大值(这两个变量,可能是int,double和const char*)。
       首先,我们用最传统的 c语言的 解决方法来写代码:
#include <stdio.h>
#include <string.h>
int max_int(int a,int b){
    return a > b ? a : b;
}
double max_double(double a,double b){
    return a > b ? a : b;
}
const char* max_char(const char* a,const char* b){
    return strcmp(a,b) > 0 ? a : b;
}
int main()
{
    printf("%d\n",max_int(100,200));
    printf("%f\n",max_double(1.2,2.2));
    printf("%s\n",max_char("hello","world"));
    return 0;
}
        因为变量的类型不同,我们必须设计不一样的函数去分别解决他们。
        一共有三种类型,就要去定义三个函数,如果有100种类型,就要去定义100个函数。这就是函数的一个缺点: 虽然能保证函数结果不会出一点错,但是必须为不同类型的进行不同的函数实现。
        是不是感觉有点麻烦啊?你说有没有什么简单的方法啊?(c语言中没有函数重载哦,重载我们下面再讲。)其实在之前c程序猿就开始想这个问题了——如果做到 类型无关。
        于是,在c语言中就提出了一个东西—— 函数宏(带参宏)
        关于什么是函数宏我们这里不做过多的介绍,如果又不懂的同学请自觉向度娘学习。我们用函数宏的方法,解决上面的这个问题:
#include <stdio.h>
#include <string.h>
#define Max(a,b) ((a) > (b) ? (a) : (b))
int main()
{
    printf("%d\n",Max(100,200));
    printf("%f\n",Max(1.2,2.2));
    printf("%s\n",Max("hello","world"));
    return 0;
}

       函数宏的原理就是,在预编译时所有Max(a,b) 都会自动被替换为((a) > (b) ? (a) : (b))。所以我们可以看到答案基本正确。但是请仔细看第三个答案,为什么“hello”比“world”大!按照字符串比较原则, 明明“world”大啊!
       还记得我们在进行字符串比较的时候都是用strcmp()函数的吗?直接比较会有什么后果?直接比较的话,其实比较的是两个const char*变量,是在比较指针而不是指针所指向字符串的值!!!这就是函数宏的一个缺点: 虽然能适用于大多数参数类型, 不能保证所有对所有类型都安全。
       看来在c中没有很好的解决这个问题啊!
       我们用c++来试试!其实我知道你憋了很久了,你肯定迫不及待的想使用 函数重载了!(如果你对于c++的函数重载还不是很懂,欢迎点开我的 【c++笔记二】重载(overload)之一看你就懂)
下面我们就用函数重载写一写:
#include<iostream>
using namespace std;
int Max(int a,int b){
    return a>b?a:b;
}
double Max(double a,double b){
    return a>b?a:b;
}
string Max(string a,string b){
    return a>b?a:b;
}
int main()
{
    cout<<Max(100,200)<<endl;
    cout<<Max(1.2,2.2)<<endl;
    cout<<Max("hello","world")<<endl;
    return 0;
}

       在c++中我们用string类取代了c语言中的字符串数组(char*),直接使用“>”去比较两个字符串就更安全了。
       或许你可以发现,针对三个类型我们还是写了三个函数,但是和c语言比较起来至少函数名都一样了(不用费脑筋去想各种各样的函数名了)。而且你发现没有,函数的实现体都是一模一样的,这样的重载函数多了,你会发现代码有点 冗余。
       所以,c++正式引入—— 模板!
       终于扯到我们今天的重点上来了,模板在经历了我们说的:函数、宏函数、重载之后,综合了三者所长。你想,你做个视频,网上有各种视频模板素材,你只要套着模板自己修改一下就可以做出高大上的视频了。做PPT也可以用模板、做简历也有模板。生活中充斥着各种各样的模板,模板给我们带来的便利自然不用我多说吧?童同样的,用上了c++的模板之后,我们也可以省很多事呢!下面正式开始讲解模板。

二、模板的定义和使用

1.定义语法:

template<typename 类型形参1, typename 类型形参2, ...>
返回类型 函数模板名 (调用形参表) { 
       函数体; 
}

       首先你要用一个template(模板的英文名)关键字表明你要开始写模板啦!然后在“<>”里面,写上你typename(类型名字)+函数中要用到的形参名,这样你就不用指定具体的形参的参数类型啦,可以写不止一个哦!换一行我们继续来写具体的函数实现体。返回类型和形参类型都可以用"<>"里面定义的那些名字来代替哦!
       我们具体看看怎么做吧?把一开始写的那个代码,改成用模板来写!
template<typename T>
T Max(T a,T b){
    return a>b?a:b;
}
我们的函数体,就浓缩为这四行了。这就是模板的魅力之处——可通用所有的类型!这里你需要特别注意这个typename关键字定义的T,它代表的是任何合法的数据类型,无论是系统定义的(int、double之类的)或者是你自己定义的结构体或类类型都可以的!

2.模板的使用

        模板是定义出来 了,我们怎么去使用他们呢?肯定有自己独特的使用方法吧!
函数模板名<类型实参1, 类型实参2, ...> (调用实参表);
       使用函数模板其实也很简单,就比调用普通函数多了一个“<>”。这个"<>"里面需要你写上你具体想用哪种数据类型去 实例化模板!(原理下面再讲,先学会怎么去用)
       所以我们调用模板,把最开始写的代码运行起来!
#include<iostream>
using namespace std;
template<typename T>
T Max(T a,T b){
    return a>b?a:b;
}
int main()
{
    cout<<Max<int>(100,200)<<endl;
    cout<<Max<double>(1.2,2.2)<<endl;
    cout<<Max<string>("hello","world")<<endl;
    return 0;
}

Max<int>(100,200),我们是在告诉编译器,100和200是int类型的,你用int类型去使用模板就好了!函数模板中的T就会自动变成int类型啦。
       那到底编译器是如何实现这种功能的呢?我们在一起看看模板的实现方法。

3.模板的实现

模板是如何做到这样强大的功能的呢?很简单,就四个字: 二次编译!
       1)第一次编译,是编译器针对函数模板的 定义所做的编译, 一般性的语法检查,生成关于该模板的内部表示。
       2)第二次编译,是编译器针对函数模板的 调用所做的编译,用所提供的类型实参结合其内部表示中的类型形参,做类型相关性检查,生成针对 具体函数的机器指令。

       第一次编译,也就是在静态时期,编译器只是检查一下你的函数体实现有没有什么语法错误,这时候不考虑数据的类型。
       第二次编译,是发生在运行时期,编译器会根据你提供的数据类型,去替换第一次编译时暂代的模板,实现具体的代码指令。
       特别注意一点, 函数的模板不是函数,只是一个模板!只有这个模板被具体的数据类型实例化之后,才是一个可以使用的函数!
       其实模板也就这么简单是吧!当然不是,还有很多需要注意的地方哦!继续往下看。

4.隐式推断

       你有没有想过,如果这句话:Max<int>(100,200)中的“<>”那部分你没有写会怎么样呢?我们一起试验一下。
#include<iostream>
using namespace std;
template<typename T>
T Max(T a,T b){
    return a>b?a:b;
}
int main()
{
    cout<<Max(100,200)<<endl;
    cout<<Max(1.2,2.2)<<endl;
    cout<<Max("hello","world")<<endl;
    return 0;
}


       我们在调用函数模板的时候,都把“<>”部分省略了。程序没有报错,运行起来了,不过结果和我们所想的有所偏差。输出的结果和用宏函数时一样,第三个输出结果出错了。
       其实这里发生了“ 隐式推断”。编译器自动(隐式)地去推断了实参的类型,并告诉模板怎么具体的去实例化。
       是不是真的这样呢?我们函数模板的实现体中检测一下参数类型不就可以证明到底编译器是不是真的做了隐式推断。这里我们需要用到typeid(不懂的还是度娘哦)。
#include <iostream>
#include <typeinfo>
using namespace std;
template<typename T>
T Max(T a,T b){
    cout<<typeid(T).name()<<": ";
    return a>b?a:b;
}
int main()
{
    cout<<Max(100,200)<<endl;
    cout<<Max(1.2,2.2)<<endl;
    cout<<Max("hello","world")<<endl;
    return 0;
}


       我们在函数实现体中,先输出一下T的具体类型。我们在调用Max(100,200),编译器隐式推断出,100和200的类型为i(int)。同理,编译器也知道1.2和2.2类型为d(double)。我们注意,编译器认为“hello”和“world”的类型是PKc(const char*),所以他们实际上是在比较指针啊亲!(编译器可没那么聪明,知道把他们堪为string对象去比较)所以为什么比较结果显示“hello”大了(可能“hello”指针的值,就是指针的地址更大)。

       隐式推断的定义: 如果函数模板的调用参数(圆括号中的参数)的类型和 模板的模板参数(尖括号中的参数) 相关 ,那么在调用该函数模板时,即使不显式指定模板实参,编译器也有能力根据调用参数的类型推断出正确的模板实参,以获得与普通函数调用一致的语法表达。
       既然有隐式推断了,我们以后就不写模板参数了吧!这肯定不行,有 三种情况,是不能用隐式推断的:
A.模板参数与调用参数的类型无关
       我们看例子:

       调用参数是T类型的,而模板参数中还有一个R。因为R和函数参数 无关,编译器根本不能隐式推断出R的具体类型,所以编译器报错了,编译器最后一行说了,不能推断出模板参数R!

B.隐式推断不允许隐式类型转换
       我们先来看一个普通的代码:
#include <iostream>
using namespace std;
void show(i a){
    cout<<a<<endl;
}
int main()
{
    char ch='a';
    show(ch);
    return 0;
}
       show函数是用来输入int类型的形参a的,但是我们在主函数中调用show函数的时候,传入的实参却是一个char类型的变量ch。但是程序还是运行起来了,并且正确的输出了字母a 的ASCII码。这里,发生了 隐式类型转换,将char隐式的转换为了int。
       那么隐式推断能不能也能隐式类型转换呢?

       我们同时传入了一个int和char参数。但是模板中要求的两个参数要相同,这里不能发生隐式类型转换了,所以不能隐式推断!
       解决这种问题方法其实也很简单:强制类型转换和显示给定模板参数。如下:
#include <iostream>
using namespace std;
template<typename T>
void show(T a,T b){
    cout<<a<<" "<<b<<endl;
}
int main()
{
    show(10,(int)'a');
    show<int>(10,(int)'a');
    return 0;
}


C.返回类型不能隐式推断。
       我们还是直接看代码:

        我们调用模板add时候,只显示的给定了T参数的类型为int,编译器并不知道返回值的类型,所以记住,返回类型不能隐式推断。


 

三、函数模板的重载

1.定义:

在同一作用域中,函数名相同,参数表不同的  函数模板和函数模板  或者  函数模板和普通函数  之间构成重载关系。  
       是不是和函数的重载的定义有几分类似?!模板的重载不仅可以发生在模板之间,还能发生在普通函数和模板之间,好神奇哦!
template<typename T>
T Max(T a,T b){
    return a > b ? a : b;
}
const char* Max(const char& a,const char* b){
    return strcmp(a,b) > 0 ? a : b;
}
template<typename T>
T Max(T a,T b,T c){
    return Max(Max(a,b),c);
}
       第一和第三个是函数模板,第二个是普通函数。我们可以发现三者的函数名皆相同,他们构成了重载关系。
       第一个模板函数和第二个普通函数,参数表不同所以是重载关系。
       第一个模板函数和第三个模板函数,模板参数个数不同所以也是重载关系。
       那么我问你一个问题哦:如果我们调用Max("hello","world"),你说编译器会调用第几个函数?这就牵涉到了模板重载的问题了。我们一起往下看重载的一些原则:

2.重载的规则:  

(1)编译器优先选择普通函数,除非函数模板能够产生更好匹配性的函数。
#include <iostream>
#include <cstring>
using namespace std;
template<typename T>
T Max(T a,T b){
    cout<<"T Max(T,T): ";
    return a > b ? a : b;
}
const char* Max(const char* a,const char* b){
    cout<<"const char* Max(const char*,const char*): ";
    return strcmp(a,b) > 0 ? a : b;
}
int main()
{
    cout<<Max("hello","world")<<endl;
    cout<<Max(100,200)<<endl;
    return 0;
}
       我们发现,我们调用Max("hello","world")的时候调用的却是普通函数而不是模板,按道理模板跟它也能匹配上。这就是模板重载的一大原则,优先选择普通函数。因为编译器觉得普通函数的 针对性更强一些。
       但是我们调用Max(100,200)的时候却是调用的模板,因为这时候模板的匹配性明显更好一点。这就是我们说的第一条原则。
       同时通过这种重载的方法,我们还很好的保证了如果比较的是两const char *时,函数实现体的正确性。

(2)在参数传递的过程中如果需要隐式类型转换,编译器将选择普通函数
#include <iostream>
using namespace std;
template<typename T>
T Max(T a, T b){
    cout<<"T Max(T,T): ";
    return a > b ? a : b;
}
int Max(int a,double b){
    cout<<"int Max(int,double): ";
    return a > b ? a : b;
}
int main()
{
    cout<<Max(1.23,(double)4)<<endl;
    cout<<Max(1.23,4)<<endl;
    return 0;
}

        在上面我们说隐式推断的时候,提到了:隐式推断不允许隐式类型转换。如这个程序一样,一旦发生了隐式类型转换,编译器会调用普通函数,而非模板函数。

(3)通过模板参数列表告知编译器使用函数模板时,针对指针的版本比针对任意类型的版本更具有针对性
 
       大家如果仔细观察的话, 前两条重载规则都是发生在不显示指定模板参数的情况下,模板自己做了隐式推断。
       如果我们现在,显示的指定模板参数,那么情况又有一点不同了。如果我们实参是两个 指针类型,那么: 针对指针的版本比针对任意类型的版本更具有针对性!
       我们一起看代码:
#include <iostream>
using namespace std;
template<typename T>
T Max(T a, T b){
    cout<<"T Max(T,T): ";
    return a > b ? a : b;
}
template<typename T>
T* Max(T* a, T* b){
    cout<<"T* Max(T*,T*): ";
    return a > b ? a : b;
}
const char* Max(const char* a, const char* b){
    cout<<"const char* Max(const char*,const char*): ";
    return a > b ? a : b;
}
int main()
{
    const char* ch1 = "hello";
    const char* ch2 = "world";
    cout<<Max<>(ch1,ch2)<<endl;
    return 0;
}
       这里有两个函数模板,一个普通函数构成重载。如果我们调用调用Max<>(ch1,ch2)你说编译器会调用哪个函数?
       你可能会说,这一看就调用第三个普通函数吗!两个都是const char*类型的,明显普通函数的针对性更强一些(我们在原则1中说的)!可是那时候我们调用的时候可没有"<>"这部分哦,那时候是编译器自己在隐式推断。现在我们现实调用模板参数列表"<>",编译器就一定会调用函数模板而不是普通函数了。我们一起来看看结果如何?
       果然,编译器不去调用普通函数了。因为实参类型是指针类型的,而我们刚好有没有指定模板参数具体是什么(我们写的是的空的‘<>“),这里编译器又开始隐式推断了。它推断出这是两个const char*类型的实参,是两个指针,那么编译器就会觉得针对指针版的模板比普通模板 针对性更强,就会调用针对指针版的模板。
       那我再问你一个问题,如果我们调用Max<>(&ch1,&ch2),你说编译器会调用哪个?ch1是一个一级指针,再对其&取地址,那就是二级指针啦!或许你会说,我们没有重载二级指针的模板啊!但是:N级指针不就是N-1级指针的一级指针吗?看看编译器到底用谁吧!
#include <iostream>
using namespace std;
template<typename T>
T Max(T a, T b){
    cout<<"T Max(T,T): ";
    return a > b ? a : b;
}
template<typename T>
T* Max(T* a, T* b){
    cout<<"T* Max(T*,T*): ";
    return a > b ? a : b;
}
const char* Max(const char* a, const char* b){
    cout<<"const char* Max(const char*,const char*): ";
    return a > b ? a : b;
}
int main()
{
    const char* ch1 = "hello";
    const char* ch2 = "world";
    cout<<Max<>(&ch1,&ch2)<<endl;
    return 0;
}

果不其然,编译器还是调用了针对指针版本的模板。

(4)显式指定的模板实参必须在所选择的重载版本中与调用参数的类型保持一致
你思考一下啊,上面(第三点原则)时我们调用Max<>(ch1,ch2)的时候没有写上具体的模板参数类型,编译器帮我们隐式推断了。如果我们这样写:Max<const char *>(ch1,ch2),那你说,编译器会调用第几个?
#include <iostream>
using namespace std;
template<typename T>
T Max(T a, T b){
    cout<<"T Max(T,T): ";
    return a > b ? a : b;
}
template<typename T>
T* Max(T* a, T* b){
    cout<<"T* Max(T*,T*): ";
    return a > b ? a : b;
}
const char* Max(const char* a, const char* b){
    cout<<"const char* Max(const char*,const char*): ";
    return a > b ? a : b;
}
int main()
{
    const char* ch1 = "hello";
    const char* ch2 = "world";
    cout<<Max<const char*>(ch1,ch2)<<endl;
    return 0;
}

       奇怪,显示的指定模板参数类型是const char*之后,它居然不调用针对指针版本的了!按道理,指针版本的更适合调用函数的指针类型啊?
       其实是这样的,我们显示的指定模板参数是const char* 之后,T就等价于const char* ,那你说T*等价于什么?当然是const char* *注意,这时候T*就是一个二级指针。 而我们的调用函数是一级指针,当然不太匹配啊。所以显示指定模板参数的时候,编译器会选择类型和调用参数保持一致的重载版本。


(5)在函数模板的实例化函数中,编译器仍然优先选择普通函数,前提是该函数必须在函数模板被第一次编译时可见。
我们先来一起分析代码:
#include <iostream>
#include <cstring>
using namespace std;
template<typename T>
T Max(T a, T b){
    cout<<"T Max(T,T): ";
    return a > b ? a : b;
}
const char* Max(const char* a, const char* b){
    cout<<"const char* Max(const char*,const char*)"<<endl;
    return strcmp(a,b)>0?a:b;
}
template<typename T>
T Max(T a,T b,T c){
    cout<<"T Max(T,T,T)"<<endl;
    return Max(Max(a,b),c);
}
int main()
{
    const char* ch1 = "123";
    const char* ch2 = "12";
    const char* ch3 = "1";
    cout<<Max<const char*>(ch1,ch2,ch3)<<endl;
    return 0;
}

       这次我们不再是比较两个变量的最大值了,而是三个,所以我们调用Max<const char*>(ch1,ch2,ch3)的时候肯定会调用含有三个变量的函数模板。所以我们在第一行看见输出了T Max(T,T,T)。可是程序没有我们想的那么简答,而是继续输出了两行。为什么呢?
       这和我们T Max(T,T,T)这个函数模板的实现有关。你可以看见,这个函数模板返回的是:Max(Max(a,b),c)。返回的时候还调用了Max含有两个参数的版本,还是递归调用。所以再输出两行也没什么好奇怪的。
       但是你发现没有,我们在主函数中可是显示的指定了模板参数为const char*类型的哦,都现实调用模板参数了为什么最后两次还是调用的普通函数?
       是,我们是显示指定模板参数了没错,但是这个const char*只是传到了T Max(T,T,T)这个函数模板的T中,但是我们返回的Max(Max(a,b),c)可没有显示指定模板参数,当然这里就不一定会调用模板函数啦!从调用Max(Max(a,b),c)开始,又和上面提到的规则一样了(普通函数的针对性更强)。
       这里牵涉到我们前面说的模板的实现的知识。二次编译中,当我们给T Max(T,T,T)这个模板给定const char*实例化为函数的过程中,编译器还要去实例化Max(Max(a,b),c)这两个函数模板。这过程中还是会优先调用普通函数。

       但是,如果我们把const char* Max(const char*,const char*)的位置放到T Max(T,T,T)这个函数模板之后,输出结果会还是这样吗?
#include <iostream>
#include <cstring>
using namespace std;
template<typename T>
T Max(T a, T b){
    cout<<"T Max(T,T)"<<endl;
    return a > b ? a : b;
}
template<typename T>
T Max(T a,T b,T c){
    cout<<"T Max(T,T,T)"<<endl;
    return Max(Max(a,b),c);
}
const char* Max(const char* a, const char* b){
    cout<<"const char* Max(const char*,const char*)"<<endl;
    return strcmp(a,b)>0?a:b;
}
int main()
{
    const char* ch1 = "123";
    const char* ch2 = "12";
    const char* ch3 = "1";
    cout<<Max<const char*>(ch1,ch2,ch3)<<endl;
    return 0;
}

       你会发现,它不再去调用普通函数了。这是因为,普通函数在该函数模板之后,在第一次编译时,函数模板发现不了这个普通函数(无法完成静态的关联)。
       所以以后再模板中嵌套模板的时候, 大家要多多注意。
       综述, 在函数模板的实例化函数中,编译器仍然优先选择普通函数,前提是该函数必须在函数模板被第一次编译时可见。

———————————————————————————分割线——————————————————————————
       好了,今天的知识点就讲到这里了。
       我们一起来稍微总结一下:首先我们介绍了为什么要引入模板。接着我们介绍了怎么去定义和使用模板,并且分析了模板的实现方法和一些隐式推断规则。最后我们还一起推断了一下模板重载的一些规则。
       如果大家对本文有什么疑问,或者有什么不足之处,欢迎评论留言。


[C++ Template]深入模板--特化与重载 目录 第12章 特化与重载 12.2 重载函数模板 12.2.1 签名 12.2.2 重载的函数模板的局部排序 12.2.3 正式的排序原则 12.2.4 模板和非模板 12.3 显式特化 12.3.1 全局的类模板特化 12.3.2 全局的函数模板特化 12.3.3 全局成员特化 12.4 局部的类模板特化 第12章 特化与重载 目前为止,我们已经知道了:C++模板如何... 阅读详情

相关推荐

c++重载与模板

一、 模板是泛型编程的重要支持,函数和类模板在STL中运用的非常广泛,首先谈谈c中的函数重载和c++中的函数模板的区别: 1、首先,函数重载是函数名相同,但参数个数和类别不同,如果增加参数个数和参数型别就要重新编写相应的重载函数,而相对于函数模板就比较灵活,我们只要编写一个函数模板,编译器在编译是就会根据参数类型特例化出相应的版本,而且模板支持可变参数(template,..代表0个或多个参数)

monkey_D_feilong的博客 3491

c++中typeid里的PKc是什么意思?它是个什么类型?

今天写了一段c++代码,功能是通过命令行传参计算2个参数的和, 在进行参数类型转换的时候,报下以错误: 025.cpp:9:14: error: cast from pointer to smaller type 'int' loses information sum += (int)argv[i] 刚开始我没想去查在c++中进行字符类型转换的方法,而是想判断一下argv[1]...

问道·六韬 4915

C++中模板类的友元重载

一个由《程序员面试宝典》引出的问题。 描述模板类的友元重载,用C++代码实现? 这实际上考察的是下面几个问题: 1.模板类的编写 2.模板类中友元函数的编写 3.什么时候会用到友元重载?答案是各种C++中的运算符。最典型的就是输出操作符 书上给出的答案如下: #include using namespace std; template class Test; template

3509

C++怎么打印变量类型,打印参数类型?typeid().name()

返回的类型名称可能是编译器特定的,不同编译器可能会有不同的实现。运算符来获取一个表达式的类型信息。成员函数来获取类型的名称。的类型信息,返回值是一个。类型的对象,可以通过其。在C++中,可以使用。

Dontla的博客 1万+

C++泛型编程1——函数模板实例化,模板参数,重载及特化

在C++中我们都知道引入了函数重载,那么在实际应用过程中:   如果我们想要实现一个加法函数,我们可以写出很简单的代码:   int ADD(int a,int b) {   return a+b; }  上面的函数很简单,但是仔细想一下,这样就实现了加法操作嘛?当我们的实参类型为double,float时,又怎么处理加法呢?   我们可以多定义几个函数   double ADD(doubl

lixungogogo的博客 6654

光学遥感显著目标检测初探笔记总结

一张图片里最吸引注意力的部分就是显著性物体,其实是模拟人的一个注意力机制。目标是希望通过计算机的方法让我们自动定位和模拟人的这种感知能力,从而去定位场景中的一个让人感兴趣的目标。

醋酸洋红的博客 2080

C++ | 函数模板的重载(模板重载)

所谓的函数模板的重载是指,普通函数的版本,函数模板的版本和函数模板特例化的版本可以共存,例如: //普通函数版本 bool Compare(char* a, char* b) { cout << "普通函数版本" << endl; return strcmp(a, b) > 0; } //函数模板版本 template<typename T> bool Compare(T a, T b) { cout << "函数模板版本" <<

ThinPikachu的博客 5679

Xilinx FPGA 10G Ethernet Subsystem example

The 10G Ethernet subsystem provides 10 Gb/s Ethernet MAC, Physical Coding Sublayer(PCS) and Physical Medium Attachment (PMA) transmit and receive functionality over anAXI4-Stream interface.

青城扬沙的博客 2383

C++类模板的重载

C++类模板的重载

weixin_41111116的博客 2377

关于Nuttx操作系统

NuttX是一个成熟的实时操作系统

qq_28576837的博客 4092

华硕ROG幻16笔记本电脑模式切换管理工具完美替代华硕奥创中心管理工具

参考文档1这个工具可以完美替代华硕奥创中心工具,可以定制化不同模式下的CPU、GPU、风扇转速、电池计划等。是由华硕开发人员开发的一个纯绿色的系统管理工具。直接展示启动后的工具界面效果图:这个工具也可以一键式停止正在运行的华硕ASUS服务,减少不必要的资源消耗。

追梦&天空的博客 1万+

函数模板,重载函数模板,模板的显式具体化,实例化

定义好函数模板后,当程序需要该函数模板定义的具体类型的函数时,编译器会根据该函数模板生成具体类型的函数定义,这种实例化方式被称为隐式实例化。例如:函数调用Swap(i, j)导致编译器生成Swap()的一个实例,该实例使用int类型。模板并非函数定义,但使用int的模板实例是函数定义。同时编译器之所以知道需要进行定义,是由于程序调用Swap()函数时提供了int参数。直接命令编译器创建特定的实例,如Swap ()。template[函数返回类型][函数模板名](函数参数列表)

m0_63783532的博客 2622

视觉自动对焦(Z 轴运动 + 相机拍照 + 清晰度计算) 的核心程序

控制 Z 轴匀速扫动一段距离,在移动过程中等间距触发相机拍照,后台计算每张图的清晰度,最后移动到最清晰的位置,完成自动对焦。

StevenChen的博客 309

【C++模板与泛型编程】重载与函数模板

在C++编程中,重载操作符与函数模板是两项极为强大且灵活的特性。它们不仅增强了代码的可读性和复用性,还使得开发者能够更自然地表达算法逻辑。本文将从函数重载与函数模板的基本概念出发,深入探讨它们的实现方式、匹配规则以及实际应用场景,并结合代码示例进行详细讲解。

byte轻骑兵的技术小窝 1281

【工具篇】万字长文拆解 Otter.ai:语音转文字领域的「瑞士军刀」是如何炼成的?(附保姆级教程)

但需要注意,2024年欧盟已出台《AI转录伦理指南》,要求所有录音需获得参与者明确授权。举个真实案例:某硅谷创业团队用Otter.ai记录产品评审会,系统自动标红争议点并生成待办事项,会议效率提升40%。AIGC技术原理、 实时转录解析、 定价策略分析、 语音算法拆解、 多平台兼容测试、 深度学习框架、 空间计算专利。——无论是跨国会议、课堂讲座还是深夜灵感,它都能实时生成带时间戳的文本记录,准确率高达95%。(此处建议插入Otter.ai会议转录动图,展示实时字幕生成效果)(数据来源:综合参考文献整理)

商务合作|问题讨论|交流学习 请联系作者微信,加微信请务必注明来意,博客主页有联系方式 1265

玩转Docker小游戏项目系列: Docker部署红心纸牌网页小游戏

玩转Docker小游戏项目系列: Docker部署红心纸牌网页小游戏

jks212454的博客 423

C++模板函数重载规则细说

文章真的长呀,如果你能坚持看到这里,说明你是一个非常坚持且对编程有强烈兴趣的人,希望这篇文章让你在c++模板的路上有所帮助。那么接下来我们再来回顾一下这篇文章的内容。我们先介绍了模板元编程要解决的场景与问题然后我们从一个具体的模板元编程例子展开,一步步学习了模板元编程的整体内容接下来针对其核心:模板函数重载匹配规则以及模板规则进一步了解最后再给出在使用方面的一些经验供参考模板元编程他要解决的最核心的问题就是:对模板类型的判断与选择。

红军不怕远征难,万水千山只等闲 3640

【毕业设计】基于雷达与深度学习的摔倒检测——雷达数据集的建立

运动物体的微多普勒效应为人体动作识别提供了可能,基于雷达的居家检测具有良好的隐私保护性,且不易受环境因素影响(如光照、温度等),近年来已受到国内外学者的广泛关注。基于雷达与深度学习的摔倒检测使用自建的雷达数据集进行人体摔倒检测的研究。雷达数据集的建立分为雷达数据采集和雷达数据处理两部分工作。

洋洋Young的博客 3405

【Cpp筑基】一、内联函数、引用变量、函数重载、函数模板

左值(lvalue,locatable value)是指能够定位的值,它表示存储在内存中的某个位置的对象。因此,左值是可以取地址的,可以出现在赋值操作的左侧。右值(rvalue,readable value)是指不具有持久存储位置的临时值,它通常是表达式求值的结果。,如果两个函数的参数数目和类型相同,同时参数的排列顺序也相同,则它们的特征标相同,而变量名是不重要的。C++提供了一种内联函数,在 C++ 中,内联函数(inline function)是一种特殊的函数,其定义使用。例如,创建一个引用变量。

Shen Mu Xin's Blog 1204

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

c++中的模板和函数重载

c++中的重载和模板

cyz322649的博客 806

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

C++:函数重载及函数模板

有时候可以编写合适的函数调用来引导编译器做出你希望的选择。int a,b;a=1;b=2;//下面为函数调用#1#2#1中<>指出编译器应使用模板函数而不是非模板函数。#2中指出编译器应使用显式实例化得到的函数。

2401_86107325的博客 1166

C++模板笔记

像C/C++/Java等语言,是编译型语言,先编译后运行。它们都有一个强大的类型系统,也被称为强类型语言,希望在程序执行之前,尽可能地发现错误,防止错误被延迟到运行时。所以会对语言本身的使用造成一些限制,称之为静态语言。与之对应的,还有动态语言,也就是解释型语言。如javascript/python/Go,在使用的过程中,一个变量可以表达多种类型,也称为弱类型语言。因为没有编译的过程,所以相对更难以调试。强类型程序设计中,参与运算的所有对象的类型在编译时即确定下来,并且编译程序将进行严格的类型检查。

caijirui_rui的博客 1175

C++模板重载

C++模板重载 产生背景:需要多个对不同类型使用同一种算法函数时可以使用模板,但是并非所有的类型都使用同一种算法,为了解决这个问题,产生了模板重载。 Tips: 1.如同函数的重载一样,模板重载函数的特征标必须不同 2.并非所有的模板参数都必须是模板参数类型 显示具体化(explicit specialization):提供一个具体化函数定义 基于(ISO/ANSI C++标准) C++98标准选择的方法: 1.对于给定的函数名,可以有非模板函数、模板函数和显示具体化模板函数以及它们的重载版本 2.显示具体

yoco的博客 1490

C++ 重载和模板

其核心作用是让自定义类型(如类、结构体)能够像内置类型一样使用运算符(如+, ==, <<)或进行类型转换。在模板内部,当引用依赖于模板参数的嵌套类型时,必须使用 typename 标识这是一个类型(而非变量或函数)。模板(Templates) 是一种泛型编程机制,允许你编写与类型无关的代码,从而实现高度可复用的组件。operator关键字后接运算符符号(如+, -, []),用于定义自定义类型的运算符行为。1.可重载的运算符:如+, -, *, /, ==, [], (), <<, >>等。

qq_42974718的博客 771

C++ 函数模板的重载

**函数模板的重载**允许我们通过模板函数和普通函数,或多个模板函数,根据不同的调用参数选择适当的重载版本。这种机制结合了模板的灵活性和函数重载的多样性。

weixin_45613635的博客 932

函数模板与函数重载

函数模板与函数重载 一,什么是函数重载 1,在理解什么是函数重载之前,先理解一下函数符号生成规则,在C语言中,函数符号的生成只与函数名相关,这个是什么意思呢?如下代码: #include<stdio.h> int sum(int a,int b){return a+b;} double sum (double a,double b){return a+b;} float sum (float a,float b){return a+b;} 这些代码在main.c文件下运行,会出现这

m0_46457511的博客 1958
上一篇: 【c++笔记十三】c++中的输入、输出和文件操作
下一篇: 裘宗燕:C/C++ 语言中的表达式求值
zmyoukonw
博客等级 码龄14年 19粉丝 16原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值